// SPDX-License-Identifier: MIT

/*
* ZIGGY - The World's First Surfing Iguana Token on BASE 
* 
* Meet Ziggy, the Surfing Blue Iguana!
* More than a meme coin—it's a lifestyle.
* Join the Ziggy wave and ride the tide of adventure, conservation, and good vibes!
* Together, we're making waves for a better planet—one token, one wave, one vibe at a time.
* 
* Total Supply: 1B $ZIGGY
* Zero taxes, 100% community-driven
* 
* Website: https://www.ziggyonbase.com
* Telegram: https://www.t.me/ziggyonbase
* Twitter: https://x.com/ZiggyOnBase
*
* Catch the Wave! Follow, Share, and Join the Movement Today!
*/

pragma solidity 0.8.24;

interface ZiggyErrors {
    error ShortZiggyBalance(address sender, uint256 ziggyBalance, uint256 ziggyNeeded);   
    error BunkSenderAddress(address sender);             
    error BunkReceiverAddress(address receiver);         
    error ShortAllowance(address spender, uint256 allowance, uint256 needed);   
    error BunkApprovalAttempt(address approver);         
    error NoBeachAccess(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, ZiggyErrors {
    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 BunkSenderAddress(from);
        if (to == address(0)) revert BunkReceiverAddress(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 ShortZiggyBalance(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 BunkReceiverAddress(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 BunkSenderAddress(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 ShortAllowance(spender, currentAllowance, value);
        unchecked { _approve(owner, spender, currentAllowance - value, false); }
    }
  
    function _isMintingLocked() internal view virtual returns (bool) {
        return false;
    }
}

contract ZiggyToken is ERC20, Ownable {
    uint256 public constant MAX_SUPPLY = 1_000_000_000 * 1e18; // 1 billion tokens
    bool private _mintingLocked = false;

    event MintingLocked();  

    constructor() ERC20("Ziggy", "ZIGGY") Ownable(_msgSender()) {
        // Initial distribution
        uint256 liquidityAllocation = (MAX_SUPPLY * 93) / 100;    // 93% - LP Liquidity
        uint256 treasuryAllocation = (MAX_SUPPLY * 7) / 100;      // 7% - Treasury (1 year linear vesting)

        // Initial token distribution
        _mint(0x70764258cEfDEAaC2dAddC1d73189c283170226F, liquidityAllocation);      // 93% Liquidity
        _mint(0x7c132752786Ac21640024cD34B3ca684cd9ffe15, treasuryAllocation);       // 7% Treasury - 1 Year Linear UNCX Vesting

        // Lock minting immediately after initial distribution
        _mintingLocked = true;
        emit MintingLocked();
    }

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

    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": {
    "ZiggyToken.sol": "ZiggyToken"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}