ticketchain/contracts/EventManager.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.8.2 <0.9.0;

import {ContractRegistry} from '@flarenetwork/flare-periphery-contracts/coston2/ContractRegistry.sol';
/* THIS IS A TEST IMPORT, in production use: import {FtsoV2Interface} from "@flarenetwork/flare-periphery-contracts/coston2/FtsoV2Interface.sol"; */
import {TestFtsoV2Interface} from '@flarenetwork/flare-periphery-contracts/coston2/TestFtsoV2Interface.sol';

contract EventManager {
  TestFtsoV2Interface internal ftsoV2;
  bytes21[] public feedIds = [
    bytes21(0x01464c522f55534400000000000000000000000000) // FLR/USD
    // bytes21(0x014254432f55534400000000000000000000000000), // BTC/USD
    // bytes21(0x014554482f55534400000000000000000000000000) // ETH/USD
  ];

  constructor() {
    /* THIS IS A TEST METHOD, in production use: ftsoV2 = ContractRegistry.getFtsoV2(); */
    ftsoV2 = ContractRegistry.getTestFtsoV2();
  }

  struct Event {
    string name;
    string description;
    uint256 capacity;
    uint256 ticketsSold;
    uint256 ticketPrice; // in USD cents
    uint256 eventDate;
    string[] images; // array of image URLs
    uint256[] tickets;
    address payable eventHost;
  }

  struct Ticket {
    address holder;
    uint256 boughtTime;
    uint256 eventId;
  }

  event EventCreated(uint256 eventId, string name, uint256 eventDate);
  event TicketPurchased(
    uint256 ticketId,
    uint256 eventId,
    address buyer,
    uint256 price
  );
  event TicketTransferred(uint256 ticketId, address from, address to);
  event TicketTransferApproved(
    uint256 ticketId,
    address owner,
    address trustee
  );

  mapping(uint256 => Event) public events;
  mapping(uint256 => Ticket) public tickets;

  mapping(uint256 => mapping(address => bool)) ticketAllowance;

  mapping(address => uint256[]) public userTickets;

  uint256 public eventCounter;
  uint256 public ticketCounter;

  function getFtsoV2CurrentFeedValues()
    public
    view
    returns (
      uint256[] memory _feedValues,
      int8[] memory _decimals,
      uint64 _timestamp
    )
  {
    return ftsoV2.getFeedsById(feedIds);
  }

  function getFlareFeed()
    public
    view
    returns (uint256 _feedValue, int8 _decimals, uint64 _timestamp)
  {
    uint256[] memory feedValues;
    int8[] memory decimals;
    uint64 timestamp;
    (feedValues, decimals, timestamp) = ftsoV2.getFeedsById(feedIds);
    return (feedValues[0], decimals[0], timestamp);
  }

  function centsToFlare(uint256 _cents) public view returns (uint256 _flr) {
    uint256 feedValue;
    int8 decimals;
    (feedValue, decimals, ) = getFlareFeed();
    return (_cents * power(10, decimals) * 1 ether) / 100 / feedValue;
  }

  function power(uint base, int8 exponent) private pure returns (uint) {
    require(exponent >= 0, 'Exponent must be non-negative');
    uint result = 1;
    for (int8 i = 0; i < exponent; i++) {
      result *= base;
    }
    return result;
  }

  function getEventPriceFlare(
    uint256 _eventId
  ) public view returns (uint256 _flr) {
    require(_eventId < eventCounter, 'Invalid event ID');
    return centsToFlare(events[_eventId].ticketPrice);
  }

  function createEvent(
    string memory _name,
    string memory _description,
    uint256 _capacity,
    uint256 _ticketPrice,
    uint256 _eventDate,
    string[] memory _images
  ) public returns (uint256 _eventId) {
    events[eventCounter] = Event(
      _name,
      _description,
      _capacity,
      0,
      _ticketPrice,
      _eventDate,
      _images,
      new uint256[](0),
      payable(msg.sender)
    );
    eventCounter++;
    emit EventCreated(eventCounter - 1, _name, _eventDate);
    return eventCounter - 1;
  }

  function getEventImages(
    uint256 _eventId
  ) public view returns (string[] memory) {
    require(_eventId < eventCounter, 'Invalid event ID');
    return events[_eventId].images;
  }

  function getEventTickets(
    uint256 _eventId
  ) public view returns (uint256[] memory) {
    require(_eventId < eventCounter, 'Invalid event ID');
    return events[_eventId].tickets;
  }

  function buyTicket(
    uint256 _eventId
  ) public payable returns (uint256 _ticketId) {
    require(_eventId < eventCounter, 'Invalid event ID');
    require(
      events[_eventId].eventDate > block.timestamp,
      'Event has already passed'
    );
    require(
      events[_eventId].tickets.length < events[_eventId].capacity,
      'Event is full'
    );

    uint256 ticketCost = getEventPriceFlare(_eventId); // Get ticket price in FLR
    require(msg.value >= ticketCost, 'Insufficient value provided'); // Ensure user has paid >= ticket price
    if (msg.value > ticketCost) {
      // Pay any excess the user paid
      (bool sentExcess, ) = msg.sender.call{value: msg.value - ticketCost}('');
      require(sentExcess, 'Failed to send FLR excess back to buyer');
    }

    // Create new ticket
    tickets[ticketCounter] = Ticket(msg.sender, block.timestamp, _eventId);

    // Add ticket to user
    userTickets[msg.sender].push(ticketCounter);

    ticketCounter++;

    // Update number of tickets sold
    events[_eventId].tickets.push(ticketCounter - 1);
    events[_eventId].ticketsSold++;

    // Transfer FLR to event host
    (bool sentToHost, ) = events[_eventId].eventHost.call{value: ticketCost}(
      ''
    );
    require(sentToHost, 'Failed to send FLR to event host');

    emit TicketPurchased(ticketCounter - 1, _eventId, msg.sender, ticketCost);
    return ticketCounter - 1;
  }

  function transferTicketForce(uint256 _ticketId, address _to) private {
    require(_ticketId < ticketCounter, 'Invalid ticket ID');
    require(
      events[tickets[_ticketId].eventId].eventDate > block.timestamp,
      'Event has already passed'
    );

    address prevHolder = tickets[_ticketId].holder;

    // Get index of ticket in holder's array
    bool found = false;
    uint256 i = 0;
    for (; i < userTickets[prevHolder].length; i++) {
      if (userTickets[prevHolder][i] == _ticketId) {
        found = true;
        break;
      }
    }

    require(found, "Ticket not found in sender's inventory");

    // Remove ticket from holder's array
    for (; i < userTickets[prevHolder].length - 1; i++) {
      userTickets[prevHolder][i] = userTickets[prevHolder][i + 1];
    }
    userTickets[prevHolder].pop();

    // Add ticket to _to's array
    userTickets[_to].push(_ticketId);

    tickets[_ticketId].holder = _to;

    emit TicketTransferred(_ticketId, prevHolder, _to);
  }

  function approveTicket(uint256 _ticketId, address _to, bool _allowed) public {
    require(_ticketId < ticketCounter, 'Invalid ticket ID');
    require(
      tickets[_ticketId].holder == msg.sender,
      'You do not own this ticket'
    );
    ticketAllowance[_ticketId][_to] = _allowed;

    emit TicketTransferApproved(_ticketId, msg.sender, _to);
  }

  function transferTicketFrom(uint256 _ticketId, address _to) public {
    require(
      ticketAllowance[_ticketId][msg.sender],
      'You are not allowed to transfer this ticket'
    );
    ticketAllowance[_ticketId][msg.sender] = false;
    transferTicketForce(_ticketId, _to);
  }

  function transferTicket(uint256 _ticketId, address _to) public {
    require(_ticketId < ticketCounter, 'Invalid ticket ID');
    require(
      tickets[_ticketId].holder == msg.sender,
      'You do not own this ticket'
    );
    transferTicketForce(_ticketId, _to);
  }
}