// SPDX-License-Identifier: MIT

// Meme Music - BEATs on BASE
// Twitter : https://x.com/BeatsOnBase
// Telegram : https://t.me/BeatsOnBase
// Website : https://www.beatsonbase.ai

/*
    Good memes have motion. Great memes have music!
    Created to celebrate memes and music while pushing the limits of AI technology.
    Launched on Base Chain for true mass adoption - where innovation meets accessibility.
*/

pragma solidity 0.8.19;

interface IBeatsErrors {
    error NotEnoughBeats(address sender, uint256 beatsBalance, uint256 beatsNeeded);   
    error BeatDropFailed(address sender);                                              
    error NoBackstagePass(address receiver);                                           
    error BeatsTooLow(address spender, uint256 allowance, uint256 needed);   
    error NotInBeatsStudio(address approver);                                          
    error NotTheKoalaDJ(address spender);                                              
}

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

abstract contract Ownable is Context {
    address private _owner;

    error OwnableUnauthorizedAccount(address account);
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor(address initialOwner) {
        if (initialOwner == address(0)) revert OwnableInvalidOwner(address(0));
        _transferOwnership(initialOwner);
    }

    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }

    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) revert OwnableUnauthorizedAccount(_msgSender());
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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 value) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
}

abstract contract ERC20 is Context, IERC20, IERC20Metadata, IBeatsErrors {
    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 override returns (string memory) {
        return _name;
    }
  
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }
  
    function decimals() public view virtual override 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 value) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }
  
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }
  
    function approve(address spender, uint256 value) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value, true);
        return true;
    }
  
    function transferFrom(address from, address to, uint256 value) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }
  
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) revert BeatDropFailed(from);
        if (to == address(0)) revert NoBackstagePass(to);
      
        _update(from, to, value);
    }
  
    function _update(address from, address to, uint256 value) internal virtual {
        if (from != address(0)) {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) revert NotEnoughBeats(from, fromBalance, value);
            unchecked { _balances[from] = fromBalance - value; }
        } else {
            _totalSupply += value;
        }
      
        if (to != address(0)) {
            unchecked { _balances[to] += value; }
        } else {
            _totalSupply -= value;
        }
      
        emit Transfer(from, to, value);
    }
  
    function _mint(address account, uint256 value) internal virtual {
        if (account == address(0)) revert NoBackstagePass(account);
        require(!_isMintingLocked(), "Minting is locked");
        _update(address(0), account, value);
        emit Transfer(address(0), account, value);
    }
  
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) revert BeatDropFailed(account);
        _update(account, address(0), value);
    }
  
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal {
        _allowances[owner][spender] = value;
        if (emitEvent) emit Approval(owner, spender, value);
    }
  
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = _allowances[owner][spender];
        if (currentAllowance < value) revert BeatsTooLow(spender, currentAllowance, value);
        unchecked { _approve(owner, spender, currentAllowance - value, false); }
    }
  
    function _isMintingLocked() internal view virtual returns (bool) {
        return false;
    }
}

contract BeatsOnBase is ERC20, Ownable {
    uint256 public constant MAX_SUPPLY = 808_808_808 * 1e18; // Drop the beat!
    bool private _mintingLocked = false;

    event MintingLocked();  

    constructor() ERC20("BEATS on BASE", "BEATS") Ownable(_msgSender()) {
        // Initial distribution for the greatest meme music project
        uint256 liquidBeats = (MAX_SUPPLY * 68) / 100;       // 68% - LP Liquidity - 4 Year Lock
        uint256 vestedBeats = (MAX_SUPPLY * 8) / 100;        // 8% each allocation

        // Press play, start Meme Music - Initial token distribution
        _mint(0x2BB53B3bf4AbbBcEAfE3290cA5f543c5209Dde48, liquidBeats);     // 68% LP - 4 Year Lock
        _mint(0xf827E45503bAc23b8A482F160bd450a567dc165C, vestedBeats);     // 8% Creation & Expansion - 4 Year Linear UNCX Vesting
        _mint(0xa110fD927770FF2Adfef2f78E634A69Ed17505b5, vestedBeats);     // 8% Marketing - 4 Year Linear UNCX Vesting
        _mint(0x4ea1303a5ED8E55c211bd4398356EE79B5894F7a, vestedBeats);     // 8% Team Allocation - 4 Year Linear UNCX Vesting
        _mint(0x2b8f17E2e8440026bC885A6B87962d60DA5d5d45, vestedBeats);     // 8% Giveaways - 1 Year Linear UNCX Vesting
    }

    function burn(uint256 value) public {
        _burn(_msgSender(), value);
    }

    function lockMinting() external onlyOwner {
        _mintingLocked = true;
        emit MintingLocked();  
    }

    function _isMintingLocked() internal view override returns (bool) {
        return _mintingLocked;
    }

    function isMintLocked() external view returns (bool) {
        return _mintingLocked;
    }

    function isRenounced() external view returns (bool) {
        return owner() == address(0);
    }
}

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