Events

AttendanceToken.sol

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

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract AttendanceToken is ERC1155, Ownable {
    mapping(uint256 => string) private _tokenURIs;

    constructor() ERC1155("") {}

    function setTokenURI(uint256 tokenId, string memory tokenURI) external onlyOwner {
        _tokenURIs[tokenId] = tokenURI;
    }

    function uri(uint256 tokenId) public view override returns (string memory) {
        return _tokenURIs[tokenId];
    }

    function mintAttendanceToken(address attendee, uint256 eventId, uint256 amount) external onlyOwner {
        _mint(attendee, eventId, amount, "");
    }
}

EventManager.sol

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

import "./EventTickets.sol";
import "./AttendanceToken.sol";

contract EventManager is Ownable {
    EventTickets public eventTickets;
    AttendanceToken public attendanceToken;

    constructor(address _eventTickets, address _attendanceToken) {
        eventTickets = EventTickets(_eventTickets);
        attendanceToken = AttendanceToken(_attendanceToken);
    }

    function markAttendance(uint256 ticketId) external {
        address ticketOwner = eventTickets.ownerOf(ticketId);
        require(ticketOwner == msg.sender, "Not the ticket owner");

        uint256 eventId = eventTickets.ticketToEvent(ticketId);
        eventTickets.burnTicket(ticketId);
        attendanceToken.mintAttendanceToken(msg.sender, eventId, 1);
    }
}

EventTickets.sol

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract EventTickets is ERC721, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    struct Event {
        uint256 ticketPrice;
        uint256 availableTickets;
        uint256 totalTickets;
    }

    mapping(uint256 => Event) public events;
    mapping(uint256 => uint256) public ticketToEvent;

    constructor() ERC721("EventTickets", "EVTK") {}

    function createEvent(uint256 eventId, uint256 ticketPrice, uint256 totalTickets) external onlyOwner {
        require(events[eventId].totalTickets == 0, "Event already exists");
        events[eventId] = Event(ticketPrice, totalTickets, totalTickets);
    }

    function buyTicket(uint256 eventId) external payable {
        Event storage event_ = events[eventId];
        require(event_.availableTickets > 0, "No tickets available");
        require(msg.value >= event_.ticketPrice, "Insufficient payment");

        _tokenIds.increment();
        uint256 newTicketId = _tokenIds.current();
        _safeMint(msg.sender, newTicketId);
        ticketToEvent[newTicketId] = eventId;
        event_.availableTickets--;

        if (msg.value > event_.ticketPrice) {
            payable(msg.sender).transfer(msg.value - event_.ticketPrice);
        }
    }

    function getAvailableTickets(uint256 eventId) external view returns (uint256) {
        return events[eventId].availableTickets;
    }

    function getTicketPrice(uint256 eventId) external view returns (uint256) {
        return events[eventId].ticketPrice;
    }

    function burnTicket(uint256 ticketId) external {
        require(ownerOf(ticketId) == msg.sender, "Not the ticket owner");
        _burn(ticketId);
        delete ticketToEvent[ticketId];
    }
}