Semestral Tasks

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

/// @notice Interface of the festival's money
interface IFestCoin {

    // -------------------------------- Events --------------------------------

    /// @notice Emitted when someone bought coins.
    /// @param buyer  Address that bought the coins
    /// @param coins  Number of coins bought
    event CoinsBought(address indexed buyer, uint256 coins);

    /// @notice Emitted for every payment, whether made with pay or payFrom.
    /// @param from    Address whose coins were paid
    /// @param to      Address that received the coins
    /// @param amount  Number of coins paid
    event Paid(address indexed from, address indexed to, uint256 amount);

    /// @notice Emitted when someone set how many of their coins a spender may use.
    /// @param owner    Address that owns the coins
    /// @param spender  Address that may spend them
    /// @param limit    Number of coins the spender may use
    event Allowed(address indexed owner, address indexed spender, uint256 limit);

    /// @notice Emitted when someone cashed out coins for ETH.
    /// @param account  Address that cashed out
    /// @param coins    Number of coins cashed out
    event CashedOut(address indexed account, uint256 coins);

    // ---------------------- Public & external functions ---------------------

    /// @notice Buy coins for exactly 0.001 ether each.
    function buyCoins() external payable;

    /// @notice Get the coins of an address.
    /// @param account  Address to check
    /// @return         Number of coins
    function getCoins(address account) external view returns (uint256);

    /// @notice Get the number of coins in existence.
    /// @return  Number of coins
    function getTotalCoins() external view returns (uint256);

    /// @notice Pay coins from the caller to another address.
    /// @param to      Address that receives the coins
    /// @param amount  Number of coins
    function pay(address to, uint256 amount) external;

    /// @notice Let a spender use up to a number of the caller's coins.
    /// @param spender  Address that may spend the coins, a person or a contract
    /// @param limit    Number of coins, replacing any previous limit
    function allow(address spender, uint256 limit) external;

    /// @notice Get how many of an owner's coins a spender may still use.
    /// @param owner    Address that owns the coins
    /// @param spender  Address that may spend them
    /// @return         Number of coins
    function getAllowance(address owner, address spender) external view returns (uint256);

    /// @notice Pay from someone else's coins, within the limit they allowed the caller.
    /// @param from    Address whose coins are paid
    /// @param to      Address that receives the coins
    /// @param amount  Number of coins
    function payFrom(address from, address to, uint256 amount) external;

    /// @notice Cash out coins for 0.001 ether each. Cashed-out coins disappear.
    /// @param amount  Number of coins
    function cashOut(uint256 amount) external;
}

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

/// @notice Interface of the festival's ticket office
interface ITickets {

    // ------------------------------ Structures ------------------------------

    /// @notice A festival ticket.
    struct Ticket {
        uint256 id;
        bool backstage;
        address owner;
    }

    // -------------------------------- Events --------------------------------

    /// @notice Emitted when the organizer set the treasury.
    /// @param treasury  Address of the treasury
    event TreasurySet(address treasury);

    /// @notice Emitted for every ticket sold, once per ticket when several are bought at once.
    /// @param ticketId   Number of the ticket
    /// @param buyer      Address that bought it
    /// @param backstage  True for a backstage pass
    event TicketSold(uint256 indexed ticketId, address indexed buyer, bool backstage);

    /// @notice Emitted when an owner gave a ticket away.
    /// @param ticketId  Number of the ticket
    /// @param from      Previous owner
    /// @param to        New owner
    event Given(uint256 indexed ticketId, address indexed from, address indexed to);

    // ---------------------- Public & external functions ---------------------

    /// @notice Set the treasury that receives the coins from ticket sales.
    /// @param treasury  Address of the treasury (the Lineup contract)
    function setTreasury(address treasury) external;

    /// @notice Buy regular tickets (50 coins each) and backstage passes (200 coins each).
    /// @dev In one purchase, the regular tickets are numbered first, then the backstage passes.
    /// @param regular    Number of regular tickets
    /// @param backstage  Number of backstage passes
    function buy(uint256 regular, uint256 backstage) external;

    /// @notice Get the ticket details.
    /// @param ticketId  Number of the ticket
    /// @return          Ticket details
    function getTicket(uint256 ticketId) external view returns (Ticket memory);

    /// @notice Get the number of tickets an address holds.
    /// @param holder  Address to check
    /// @return        Number of tickets
    function getTicketCount(address holder) external view returns (uint256);

    /// @notice Give a ticket to another address.
    /// @param ticketId  Number of the ticket
    /// @param to        New owner
    function give(uint256 ticketId, address to) external;
}

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

/// @notice Interface of the headliner vote
interface ILineup {

    // ------------------------------ Structures ------------------------------

    /// @notice An act that can headline the festival.
    struct Act {
        uint256 id;
        string name;
        address artist;
        uint256 fee;
        uint256 votes;
    }

    // -------------------------------- Events --------------------------------

    /// @notice Emitted when the organizer added an act.
    /// @param actId   Number of the act
    /// @param name    Name of the act
    /// @param artist  Address that gets paid if the act headlines
    /// @param fee     Fee in coins
    event ActAdded(uint256 indexed actId, string name, address indexed artist, uint256 fee);

    /// @notice Emitted when the organizer started the vote.
    /// @param endsAt  Timestamp when the vote ends
    event VoteStarted(uint256 endsAt);

    /// @notice Emitted for every ticket that voted, once per ticket in a batch.
    /// @param ticketId  Number of the ticket
    /// @param actId     Number of the act
    /// @param voter     Owner of the ticket at the time of voting
    /// @param votes     Votes the ticket gave (1 or 2)
    event Voted(uint256 indexed ticketId, uint256 indexed actId, address indexed voter, uint256 votes);

    /// @notice Emitted for every act booked when the vote was finalized, in booking order.
    /// @param actId      Number of the act
    /// @param artist     Address that was paid
    /// @param fee        Fee paid in coins
    /// @param headliner  True for the first act booked
    event ActBooked(uint256 indexed actId, address indexed artist, uint256 fee, bool headliner);

    /// @notice Emitted when the vote was finalized.
    /// @param actsBooked  Number of acts booked (0 when there is no headliner)
    event Finalized(uint256 actsBooked);

    /// @notice Emitted when the organizer withdrew the coins left in the treasury.
    /// @param amount  Number of coins withdrawn
    event RestWithdrawn(uint256 amount);

    // ---------------------- Public & external functions ---------------------

    /// @notice Add an act before the vote starts.
    /// @param name    Name of the act
    /// @param artist  Address that gets paid if the act headlines
    /// @param fee     Fee in coins
    function addAct(string memory name, address artist, uint256 fee) external;

    /// @notice Start the vote, which ends exactly 3 days later.
    function startVote() external;

    /// @notice Get the remaining voting time in seconds.
    /// @return  Remaining time (0 before the vote starts and after it ends)
    function getRemainingTime() external view returns (uint256);

    /// @notice Vote for an act with one of the caller's tickets.
    /// @param ticketId  Number of the ticket
    /// @param actId     Number of the act
    function vote(uint256 ticketId, uint256 actId) external;

    /// @notice Vote with several of the caller's tickets.
    /// @param ticketIds  Numbers of the tickets
    /// @param actIds     Number of the act for each ticket
    function voteBatch(uint256[] calldata ticketIds, uint256[] calldata actIds) external;

    /// @notice Check whether a ticket has already voted.
    /// @param ticketId  Number of the ticket
    /// @return          True if the ticket has voted
    function hasVoted(uint256 ticketId) external view returns (bool);

    /// @notice Get all acts sorted descending by votes.
    /// @return  Array of acts
    function getResults() external view returns (Act[] memory);

    /// @notice Finalize the vote: book the headliner and the support acts, paying each from the treasury.
    function finalize() external;

    /// @notice Get the headliner once the vote is finalized.
    /// @return found  True if there is a headliner
    /// @return act    The headlining act (empty when there is none)
    function getHeadliner() external view returns (bool found, Act memory act);

    /// @notice Get every booked act in booking order, headliner first (empty before finalizing).
    /// @return  Array of acts
    function getLineup() external view returns (Act[] memory);

    /// @notice Send all coins left in the treasury to the organizer.
    function withdrawRest() external;
}