update .gitignore to remove cache

.gitignore

@@ -35,4 +35,5 @@ yarn-error.log*
 *.tsbuildinfo
 next-env.d.ts
 artifacts
-typechain-types
+typechain-types
+cache

contracts/EventManager.sol

@@ -2,182 +2,254 @@
 
 pragma solidity >=0.8.2 <0.9.0;
 
-import {ContractRegistry} from "@flarenetwork/flare-periphery-contracts/coston2/ContractRegistry.sol";
+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";
+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
+  ];
 
-    struct Event {
+  constructor() {
-        string name;
+    /* THIS IS A TEST METHOD, in production use: ftsoV2 = ContractRegistry.getFtsoV2(); */
-        string description;
+    ftsoV2 = ContractRegistry.getTestFtsoV2();
-        uint256 capacity;
+  }
-        uint256 ticketsSold;
+
-        uint256 ticketPrice; // in USD cents
+  struct Event {
-        uint256 eventDate;
+    string name;
-        string[] images; // array of image URLs
+    string description;
-        uint256[] tickets;
+    uint256 capacity;
-        address payable eventHost;
+    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');
     }
 
-    struct Ticket {
+    // Create new ticket
-        address holder;
+    tickets[ticketCounter] = Ticket(msg.sender, block.timestamp, _eventId);
-        uint256 boughtTime;
+
-        uint256 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;
+      }
     }
 
-    event EventCreated(uint256 eventId, string name, uint256 eventDate);
+    require(found, "Ticket not found in sender's inventory");
-    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;
+    // Remove ticket from holder's array
-    mapping(uint256 => Ticket) public tickets;
+    for (; i < userTickets[prevHolder].length - 1; i++) {
-
+      userTickets[prevHolder][i] = userTickets[prevHolder][i + 1];
-    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);
     }
+    userTickets[prevHolder].pop();
 
-    function getFlareFeed() public view returns (uint256 _feedValue, int8 _decimals, uint64 _timestamp) {
+    // Add ticket to _to's array
-        uint256[] memory feedValues;
+    userTickets[_to].push(_ticketId);
-        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) {
+    tickets[_ticketId].holder = _to;
-        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) {
+    emit TicketTransferred(_ticketId, prevHolder, _to);
-        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) {
+  function approveTicket(uint256 _ticketId, address _to, bool _allowed) public {
-        require(_eventId < eventCounter, "Invalid event ID");
+    require(_ticketId < ticketCounter, 'Invalid ticket ID');
-        return centsToFlare(events[_eventId].ticketPrice);
+    require(
-    }
+      tickets[_ticketId].holder == msg.sender,
+      'You do not own this ticket'
+    );
+    ticketAllowance[_ticketId][_to] = _allowed;
 
-    function createEvent(string memory _name, string memory _description, uint256 _capacity, uint256 _ticketPrice, uint256 _eventDate, string[] memory _images) public returns (uint256 _eventId) {
+    emit TicketTransferApproved(_ticketId, msg.sender, _to);
-        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) {
+  function transferTicketFrom(uint256 _ticketId, address _to) public {
-        require(_eventId < eventCounter, "Invalid event ID");
+    require(
-        return events[_eventId].images;
+      ticketAllowance[_ticketId][msg.sender],
-    }
+      'You are not allowed to transfer this ticket'
+    );
+    ticketAllowance[_ticketId][msg.sender] = false;
+    transferTicketForce(_ticketId, _to);
+  }
 
-    function getEventTickets(uint256 _eventId) public view returns (uint256[] memory) {
+  function transferTicket(uint256 _ticketId, address _to) public {
-        require(_eventId < eventCounter, "Invalid event ID");
+    require(_ticketId < ticketCounter, 'Invalid ticket ID');
-        return events[_eventId].tickets;
+    require(
-    }
+      tickets[_ticketId].holder == msg.sender,
-
+      'You do not own this ticket'
-    function buyTicket(uint256 _eventId) public payable returns (uint256 _ticketId) {
+    );
-        require(_eventId < eventCounter, "Invalid event ID");
+    transferTicketForce(_ticketId, _to);
-        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);
-    }
-
-}