MeowToken

{{
  "language": "Solidity",
  "sources": {
    "contracts/MeowToken.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MeowToken {
    string public name = "Meow Token";
    string public symbol = "MEOW";
    uint8 public decimals = 18;
    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    mapping(address => uint256) public lastFeedingTime;
    mapping(address => uint256) public feedingStreak;
    mapping(address => uint256) public totalFeedings;

    uint256 public baseRewardPerFeeding = 10 * 10**18;
    uint256 public streakBonusPerDay = 2 * 10**18;
    uint256 public minimumFeedingInterval = 0;
    uint256 public streakResetTime = 36 hours;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event FeedingLogged(address indexed feeder, uint256 reward, uint256 streak);
    event StreakReset(address indexed feeder);

    constructor() {
        totalSupply = 1000000 * 10**18;
        balanceOf[address(this)] = totalSupply;
        emit Transfer(address(0), address(this), totalSupply);
    }

    function transfer(address to, uint256 value) public returns (bool) {
        require(balanceOf[msg.sender] >= value, "Insufficient balance");
        balanceOf[msg.sender] -= value;
        balanceOf[to] += value;
        emit Transfer(msg.sender, to, value);
        return true;
    }

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

    function transferFrom(address from, address to, uint256 value) public returns (bool) {
        require(balanceOf[from] >= value, "Insufficient balance");
        require(allowance[from][msg.sender] >= value, "Insufficient allowance");
        balanceOf[from] -= value;
        balanceOf[to] += value;
        allowance[from][msg.sender] -= value;
        emit Transfer(from, to, value);
        return true;
    }

    function logFeeding() public returns (uint256) {
        require(
            block.timestamp >= lastFeedingTime[msg.sender] + minimumFeedingInterval,
            "Must wait before next feeding reward"
        );

        if (block.timestamp > lastFeedingTime[msg.sender] + streakResetTime) {
            if (feedingStreak[msg.sender] > 0) {
                emit StreakReset(msg.sender);
            }
            feedingStreak[msg.sender] = 0;
        }

        feedingStreak[msg.sender] += 1;
        totalFeedings[msg.sender] += 1;
        lastFeedingTime[msg.sender] = block.timestamp;

        uint256 streakBonus = (feedingStreak[msg.sender] - 1) * streakBonusPerDay;
        if (streakBonus > 50 * 10**18) {
            streakBonus = 50 * 10**18;
        }

        uint256 totalReward = baseRewardPerFeeding + streakBonus;

        require(balanceOf[address(this)] >= totalReward, "Insufficient reward pool");

        balanceOf[address(this)] -= totalReward;
        balanceOf[msg.sender] += totalReward;

        emit FeedingLogged(msg.sender, totalReward, feedingStreak[msg.sender]);
        emit Transfer(address(this), msg.sender, totalReward);

        return totalReward;
    }

    function getRewardEstimate(address user) public view returns (uint256) {
        uint256 currentStreak = feedingStreak[user];

        if (block.timestamp > lastFeedingTime[user] + streakResetTime) {
            currentStreak = 0;
        }

        uint256 streakBonus = currentStreak * streakBonusPerDay;
        if (streakBonus > 50 * 10**18) {
            streakBonus = 50 * 10**18;
        }

        return baseRewardPerFeeding + streakBonus;
    }

    function canClaimReward(address user) public view returns (bool) {
        return block.timestamp >= lastFeedingTime[user] + minimumFeedingInterval;
    }

    function getTimeUntilNextReward(address user) public view returns (uint256) {
        if (block.timestamp >= lastFeedingTime[user] + minimumFeedingInterval) {
            return 0;
        }
        return (lastFeedingTime[user] + minimumFeedingInterval) - block.timestamp;
    }
}
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": false,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}