Merge pull request #10 from Ayush272002/contracts-merge

Add smart contracts

contracts/EventManager.sol

@@ -0,0 +1,195 @@
+// 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);
+    }
+
+}

package.json

@@ -10,6 +10,7 @@
     "prepare": "husky"
   },
   "dependencies": {
+    "@flarenetwork/flare-periphery-contracts": "^0.1.16",
     "@metamask/sdk-react": "^0.30.0",
     "@radix-ui/react-icons": "^1.3.0",
     "@radix-ui/react-label": "^2.1.0",