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

/**
 * @title DogeCats-Ai Token (DCAI)
 * @dev A simple ERC-20 token implementation for the Base Network.
 * @author @base)
 * @notice This contract allows for token transfers, balance checks, and minting/burning by the owner.
 */

contract DogeCats_Ai {
    // Token details
    string public name = "DogeCats Ai";
    string public symbol = "DCAI";
    uint8 public decimals = 18; // Standard ERC-20 decimals

    // Total supply of tokens (450 million with 18 decimal places)
    uint256 public totalSupply = 300000000 * (10 ** uint256(decimals));

    // Owner of the contract
    address public owner;

    // Balances of each account
    mapping(address => uint256) public balances;

    // Events
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    // Modifier to restrict access to the owner
    modifier onlyOwner() {
        require(msg.sender == owner, "Only the owner can call this function");
        _;
    }

    // Constructor to initialize the contract
    constructor() {
        owner = msg.sender;
        balances[msg.sender] = totalSupply; // Assign all tokens to the owner
        emit Transfer(address(0), msg.sender, totalSupply); // Emit transfer event for minting
    }

    // Transfer tokens to another address
    function transfer(address to, uint256 amount) external returns (bool) {
        require(to != address(0), "Invalid address"); // Prevent sending to the zero address
        require(balances[msg.sender] >= amount, "Not enough tokens");

        // Update balances
        balances[msg.sender] -= amount;
        balances[to] += amount;

        // Emit transfer event
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    // Check the token balance of an account
    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    // Transfer ownership of the contract
    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "Invalid address");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    // Mint new tokens (only owner can call this function)
    function mint(address to, uint256 amount) external onlyOwner {
        require(to != address(0), "Invalid address");

        // Increase total supply and balance of the recipient
        totalSupply += amount;
        balances[to] += amount;

        // Emit transfer event for minting
        emit Transfer(address(0), to, amount);
    }

    // Burn tokens (only owner can call this function)
    function burn(uint256 amount) external onlyOwner {
        require(balances[msg.sender] >= amount, "Not enough tokens");

        // Decrease total supply and balance of the sender
        totalSupply -= amount;
        balances[msg.sender] -= amount;

        // Emit transfer event for burning
        emit Transfer(msg.sender, address(0), amount);
    }
}

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