Tournaments

Tournaments are time-boxed competitions that run in Elata apps. You join a tournament, compete under a clear set of rules, and at the end a prize pool is paid out automatically to the people (or teams) who did best, using smart contracts instead of a centralized scoreboard. Under the hood, each tournament is powered by Elata’s tournament contracts, so entries, fees, and payouts are handled transparently onchain.

---

What is a tournament?

At a high level, a tournament is:

• A one-off event with a clear start and end time
• A shared prize pool funded by entry fees, sponsors, or both
• A rule set that determines how you “score” (e.g., points, streaks, completion)
• An automated payout to winners once the event is finalized

On Elata, tournaments are created by apps. Each app can spin up its own tournaments using the protocol’s Tournament module, so competitions are native to the app’s token economy and experience.

Some key properties:

• App-token based: Entry fees are paid in the app’s token, and prizes are denominated in both that token plus $ELTA.
• Single-use: Each tournament runs once. After it’s finalized and all rewards are claimable, that specific tournament is “closed” and can’t be reused.
• Transparent fees: A small portion of the prize pool is routed to the protocol and to token burning (deflation), and the rest goes to players. Defaults are configured in the protocol (e.g., ~2.5% protocol fee, ~1% burn), and app creators can tune them for special events.

You don’t have to think about any of the smart-contract complexity as a user—you just see “Join tournament,” “Play,” and “Claim rewards.”

---

How tournaments work

1. Creation & announcement

   An app creator or community organizer sets up a new tournament by calling the Elata TournamentFactory.

   Collectively, this mechanism deploys a fresh Tournament contract specifically for that event, registers it under the app so frontends can discover it, and applies default fee settings (protocol fee, burn fee), which can be customized for that specific tournament.

   From a user perspective perspective, you just see a new event pop up in the app with:

   • A name and description
   • Start and end time
   • Entry requirements
   • Prize breakdown (e.g., Top 10%, Top 3, winner-takes-most)
2. Joining the tournament

   During the entry window:

   • Competitors pay an entry fee in the app’s token to join the tournament.
   • The Tournament contract collects these fees and builds the prize pool.
   • A small slice of each entry goes to:
     • The Elata protocol treasury (to support ongoing development and rewards)
     • A burn address, permanently removing a small amount of tokens to make the token more scarce over time

   The app can also allow sponsored tournaments where a team, DAO, or lab seeds an initial prize pool so entry fees are low or even zero.

3. Competing in a tournament

   How you compete depends on the app. The protocol is neutral; the app defines the game or challenge.

   In theory, a tournament could be based on any of the following:

   • Scores in a game (e.g., brain-controlled Pong, reaction-time tasks)
   • Streaks or completion (e.g., “Complete a focus session every day for 7 days”)
   • Performance metrics (e.g., fastest task completion, highest level reached)
   • Off-chain or mixed activity (e.g., completing certain tasks in an app, then verifying via the app’s backend)

   The bottom line is that the scoring logic lives in the app, while the Tournament contract takes care of entries and payouts.

4. Finalization & reward calculation

   After the tournament ends:

   • The organizer (or an automated job) finalizes the tournament by submitting the final leaderboard or results to the Tournament contract.
   • The contract locks the results (single finalization; no edits can be made) and records how much each account is entitled to.
   • This entitlement list is stored in a compact, cryptographic format, so anyone can later prove “I’m entitled to X tokens” without the contract needing to store a giant list.

   From a user perspective, this just looks like: “Tournament over. You placed #3. You can claim 500 tokens.”

5. Claiming rewards

   Once finalized, users who placed in the tournament can claim their rewards directly from the Tournament contract. Each address can claim only once, and the Tournament cannot be re-opened or changed.

   The app UI will typically show:

   • Your final placement
   • Your claimable amount
   • A simple “Claim” button that triggers the contract call for you

---

Example tournament use cases

Because tournaments are merely generic “wrappers” around app activity, they can be used in a lot of ways. Not just esports or high-score lists.

Here are some ways to help people conceptualize them and when they may be used:

Gaming

Peer-to-peer Competitions

Examples may include:

• A brain-controlled video game where users play a weekly tournament and the top scores share a prize pool.
• A reaction-time challenge app that runs a daily sprint: fastest average response time over 10 trials wins.
• A speed-runner style task where players try to complete cognitive puzzles in the shortest time.

Potentially useful because:

• Gives users a clear, fun goal and recurring event to show up for
• Helps apps bootstrap engagement around key features
• Generates high-quality performance data in a structured way

Individuals, developers, and/or organizations that launch apps are ultimately responsible for applying Elata’s tournament design to align with the use case of their app. While these may be helpful use cases, there are certainly more use cases for tournaments. If you are looking to launch an app, please reference our Builders section for instructions.

---

Why tournaments matter in the Elata ecosystem

Tournaments are not just a side game, but rather they’re a core engagement and economic primitive for all ecosystem participants

Participant	Expected Utility
Users	- A way to turn participation into tangible upside (tokens, status, reputation) - A clear structure: “show up during this window, do X, potentially earn Y” - A fun, social frame for activities that might otherwise feel like chores
App Builders	- A plug-and-play way to organize events and recurring campaigns - Built-in economics: entry fees, protocol rake, and token burning are handled by the Tournament module, not custom code - A tool to drive engagement, retention, and high-quality data collection
$ELTA stakers	Tournaments contribute fees back into Elata’s shared revenue pool (the “tournament rake”), which is then split between app stakers, veELTA stakers, and the treasury. This ties fun, user-facing events directly into the health and sustainability of the overall ecosystem.

---