Explore the tools built for a new civilization in the 2026 EVE Frontier Hackathon.
Voting has ended, but the project gallery remains open.
Explore the tools built for a new civilization in the 2026 EVE Frontier Hackathon.
Voting has ended, but the project gallery remains open.

Self-executing diplomatic treaties for EVE Frontier. Sign on-chain, deposit collateral, break the pact, lose your stake.
Every war in EVE starts the same way: someone breaks a promise. Alliances negotiate pacts in Discord, but there's no enforcement. Betrayal costs nothing beyond subjective reputation.
Covenant makes betrayal expensive.
Two alliances sign a treaty on-chain, each staking SUI as collateral. An off-chain oracle monitors KillMail events — if a cross-alliance kill is detected, the contract automatically penalizes the violator with a graduated response:
- 1st violation: 20% of deposit forfeited — an incident, a warning
- 2nd violation: 40% forfeited — a pattern, escalation
- 3rd violation: 100% forfeited, treaty terminated — systematic aggression
This models how real diplomacy works. A single friendly-fire incident doesn't destroy a relationship. But repeated aggression escalates to full forfeiture. The game theory shifts: alliance leaders must actively police their own members.
The blockchain is the judge.
3-module system architecture:
covenant (core) — Treaty lifecycle: create, sign, graduated violation penalty, complete, cancel. The core state machine and escrow logic.
treaty_registry — Global treaty index with per-alliance reputation tracking. Records treaties signed, honored, violated, and computes compliance rate in basis points. Enables on-chain reputation queries.
gate_enforcer — Smart Gate extension that enforces diplomatic consequences in physical space. Violators' pilots get locked out of gates. Extends Covenant from on-chain record keeping to in-game world enforcement.
How it works:
1. Alliance A proposes treaty with SUI deposit
2. Alliance B co-signs with matching deposit — treaty activates
3. Off-chain indexer monitors KillmailCreatedEvent via Sui GraphQL
4. Cross-alliance kill detected — graduated penalty auto-applied
5. Treaty expires cleanly — both sides reclaim deposits
6. Gate Enforcer: violating alliance's members denied gate passage
Key features:
- Graduated penalty (20% / 40% / 100%) models real diplomatic escalation
- verify_violation() — anyone can independently audit, no trust in oracle required
- Treaty Registry with per-alliance compliance scores (on-chain reputation)
- Smart Gate enforcement — treaty violations have physical in-game consequences
- 24 unit tests, end-to-end verified on Sui Testnet
- Oracle decentralization roadmap: single — multi-oracle voting — fully permissionless
Built with Sui Move. 3 contract modules + TypeScript KillMail monitor.
Try it yourself:
Web: https://covenant-eve.vercel.app
Connect a Sui wallet (Testnet) to browse, propose, and sign treaties.
CLI: npx tsx demo/create.ts
Interactive treaty creation — one input + one confirmation = treaty on-chain.
Demo: npx tsx demo/demo.ts --dry-run
Watch the full lifecycle in 36 seconds — graduated penalty escalation to termination.

The Core Loop
Chain events flow in → WatchTower fingerprints behavior and scores reputation
across six dimensions → scores publish on-chain as Sui Move objects → Smart
Assemblies read those scores in the same transaction they make access control
decisions → "deny docking if trust < 40" → player behavior adapts → new chain
events flow in → the cycle tightens.
Monolith runs in parallel. Same chain data, different question. Not "who is
this entity" but "is the economy intact." 40 detection rules across 20
checkers scan every event for supply discrepancies, bot patterns,
conservation-of-mass violations, spy indicators. When something breaks,
Monolith finds it before anyone notices.
Monolith's public API and webhook subscriptions give CCP a real-time economic
audit layer that doesn't exist today — bot detection, supply integrity, state
anomalies — consumable without building it themselves. WatchTower's on-chain
reputation oracle is equally available to CCP's own Smart Assemblies as it is
to any player-deployed gate.
No other entry in this hackathon closes this loop. Dashboards show you data.
Notification bots filter events. Aegis Stack creates a feedback cycle where
on-chain reputation changes on-chain behavior. 40 detection rules. Zero
competitors in this space.
---
Why This Had to Be Sui
EVE Frontier's entire player economy lives on Sui — kills, transfers, assembly
ownership, gate transits. That makes behavioral intelligence a blockchain
problem, not a game API problem.
The critical design choice: WatchTower's reputation oracle publishes scores as
Sui Move objects so Smart Assemblies can read them in the same execution
context they're making access control decisions. The trust check and the gate
check happen in the same transaction. No bridge. No off-chain lookup. No
oracle latency window where stale data lets a bad actor through.
Sui's object model makes this possible in a way EVM storage doesn't.
Reputation scores are owned objects with structured fields that Move code can
destructure and evaluate inline. A gate contract doesn't call an API — it
reads a Sui object that already exists in the transaction's object set. That's
sub-second trust verification at the protocol layer, not the application
layer.
We built four Move modules: watchtower::subscription (three paid tiers via
native SUI transfer, SubscriptionCap as owned objects, shared registry),
watchtower::reputation (6-dimension oracle scores queryable by any Smart
Assembly), watchtower::titles (earned title grants from behavioral
thresholds), and dossier::threat_registry (live-updating NFT intelligence
cards with oracle-pushed threat scores). 68+ transactions published including
53 reputation scores and 15 titles. Package:
0x3ca7e3af5bf5b072157d02534f5e4013cf11a12b79385c270d97de480e7b7dca
---
WatchTower — Behavioral Intelligence
WatchTower turns raw on-chain behavior into identity. Every entity that acts
on the frontier leaves a trace. WatchTower finds the patterns and builds
intelligence from them — who is this pilot, where do they operate, what have
they earned, what is their reputation worth. No manual tagging. No
self-reported data. The chain doesn't lie.
What it produces:
Entity Dossiers with stats, timelines, and danger ratings. Behavioral
Fingerprints covering temporal patterns, route analysis, social networks, and
OPSEC scoring. Earned Titles — deterministic names from chain stats: "The
Reaper" (50+ kills), "The Ghost" (30+ transits, zero combat), "The
Meatgrinder" (20+ nearby kills on a gate). A Story Feed that auto-generates
news from engagement clusters, streak milestones, and hunter activity. Kill
Networks mapping attacker-to-victim relationships with vendetta detection.
Danger Zones ranking systems by kill density with resolved system names.
Alt Detection through fingerprint comparison. AI Narratives powered by Claude
with template fallback. Corp Intel with combat rankings, member aggregation,
and rivalry detection.
Reputation System:
Every entity scored 0-100 across six dimensions — Combat Honor (clean kills vs
ganking), Target Diversity (range of opponents), Reciprocity (fair fights vs
one-sided), Consistency (stable behavior over time), Community (positive-sum
actions like gate building), Restraint (new player protection). These scores
publish on-chain and flow directly into Smart Assembly access control.
The Oracle: Standing watches on entities, gates, and systems with
Discord/webhook alerts. Movement detection, traffic spikes, killmail
proximity, hostile sighting. Set a watch from any entity's threat verdict card
and receive alerts when conditions trigger — in the web UI, via Discord
webhook, or both. NEXUS dispatcher pushes enriched events to third-party
builders. Discord bot with 15 slash commands. Three subscription tiers paid
in SUI on-chain (Scout ~$4.99/wk, Oracle ~$9.99/wk, Spymaster ~$19.99/wk).
Stripe as fallback rail.
Mission Control: A BYO-LLM intel agent wired to 10 WatchTower API tools.
Connect any OpenAI-compatible endpoint — Ollama, LM Studio, or hosted — and
query the intelligence database in natural language. "Who are the most
dangerous pilots right now?" "Is it safe to travel through system X?" The
agent calls tools autonomously, retrieves live chain data, and synthesizes
tactical briefings.
In-Game Embedded Intelligence: WatchTower renders inside EVE Frontier's Smart
Assembly browser panels. Approach a gate or kiosk and see the entity
intelligence card — trust score, reputation bars, danger rating, earned
titles, and a gate recommendation (ALLOW/DENY PASSAGE) — without leaving the
game. Cache-busted headers ensure the embedded view always shows live data.
Dossier NFTs:
On-chain NFT intelligence cards (DossierCard) that auto-update with live
threat and reputation data. Three tiers: INTEL (free), CLASSIFIED (0.5 SUI),
ORACLE (2 SUI). ThreatRegistry oracle pushes per-entity scores from Monolith's
40 detection rules. The card never goes stale — trade it, and you trade
access to that entity's live intelligence feed.
---
Monolith — Anomaly Detection Engine
40 detection rules across 20 checkers. Every rule is a pure function: (events,
states) -> anomaly or nothing. Pure chain-event architecture — zero
dependency on CCP's World API for dynamic data.
Five examples of what it catches: Economic rules (E1-E4) flag supply
discrepancies and duplicate mints — if items appear without a mint event or
vanish without a destruction event, Monolith sees it. Coordinated Buying
(CB1-CB2) detects fleet staging signals from clustered wallet activity. Bot
Pattern (BP1) identifies automated transaction cadences. Tribe Hopping (TH1)
flags rapid corp changes as a spy indicator. OwnerCap Transfer (OC1) detects
ownership delegation and capability handoffs as behavioral signals.
...and 15 more checker categories covering object versioning, killmail
integrity, dead assemblies, engagement reconstruction, velocity anomalies,
wallet concentration, config changes, sequence gaps, continuity violations,
inventory auditing, POD verification, market manipulation, orbital zones,
feral AI, and chain state verification via Sui GraphQL.
Canvas2D heatmap renders 24,502 solar systems at 60fps. Item ledger tracks
every mint, transfer, and destruction. Public API v1 for anomaly queries.
Webhook subscriptions for push. Discord alerts by severity. Auto-filed GitHub
issues on CRITICAL. In-game embedded threat feed shows live anomalies inside
Smart Assembly browser panels with auto-polling and system-level filtering.
---
Architecture
Both systems ingest from Sui RPC + GraphQL on the Stillness testnet —
killmails, gate events, entity activity, object state. All data is live
chain data, not cached or simulated.
WatchTower: Indexer → Scoring Engine (fingerprinting, reputation, titles, AI
narratives) → SQLite WAL → 54 tier-gated REST endpoints + SSE live feed +
Discord bot → React 19 frontend on Vercel.
Monolith: Indexer → Detection Engine (40 rules, item ledger, chain state
verification) → SQLite WAL + FTS5 → 38 REST endpoints + Public v1 + webhooks +
Discord alerts → React 19 frontend with Canvas2D map on Vercel.
Reputation scores flow from WatchTower's scoring engine → on-chain via Sui
Move → readable by any Smart Assembly in the same transaction context.
---
By the Numbers
1,628 tests across both systems. 14,524 entities fingerprinted. 796+ anomalies
detected. 24,502 systems mapped. 67,880+ chain events ingested. 525+
killmails analyzed. 299,489 state transitions tracked. 40 detection rules
across 20 checkers. 92 API endpoints. 4 Sui Move modules. 15 Discord
commands. 68+ on-chain transactions. Both systems live in production on
Stillness.
---
Live Demo
WatchTower: https://watchtower-evefrontier.vercel.app/
WatchTower In-Game Embed: https://watchtower-evefrontier.vercel.app/embed
Mission Control: https://watchtower-evefrontier.vercel.app/mission-control
Monolith: https://monolith-evefrontier.vercel.app/
Monolith In-Game Embed: https://monolith-evefrontier.vercel.app/embed
Website: https://thewatchtower.xyz
Demo Video: https://youtu.be/I9_B6krfbXc
Repo: https://github.com/AreteDriver/watchtower
---
Track: Utility
Built by: AreteDriver

The Eternal Chronicle is a decentralized narrative engine that transforms on-chain events from the EVE Frontier blockchain universe into permanent, AI-generated chronicle entries. It monitors the Sui blockchain for milestone events — gate deployments, combat kills, pioneer arrivals, ownership transfers, and more — then runs a six-stage pipeline:
Detect milestone events via the eve-eyes indexer API
Generate narrative prose in an epic, archaic-formal voice using Gemini 2.5 Flash
Generate concept artwork in a dark space-opera aesthetic using Gemini image generation
Upload artwork to Walrus decentralized blob storage
Build individual chronicle HTML pages from templates
Publish a static site to Walrus Sites with a hero carousel and chronological feed
Each chronicle entry is idempotent (tracked by transaction digest), cost-tracked, and permanently stored on decentralized infrastructure. The system supports three modes: continuous watch polling, single-event processing, and local demo generation.
Tech stack: Node.js (ES Modules), Gemini AI (via OpenAI-compatible SDK), Walrus blob storage & Sites, Vitest + Playwright for testing.

Blood Contract is a player-driven bounty system for EVE Frontier. Players can create on-chain bounty contracts by locking rewards against a target, choosing whether the contract applies to ship kills or structure kills, defining the required kill count, and setting a contract duration. Hunters who fulfill the conditions can claim rewards directly from the contract. Core features include Standard Bounties for single-target hunts, Ship and Building kill filters for more precise objectives, Multiple Kills contracts that distribute rewards across repeated eliminations, Future Killer bounties that automatically reverse onto the killer after a player is killed, and Auto Sort that surfaces the most valuable active targets. Blood Contract transforms bounty hunting from one-off encounters into a PvP gameplay loop with clear rewards, sustained conflict, and long-term incentives.

Defensive telemetry for EVE Frontier turret operators.
Sentinel is an EVE Frontier dashboard for monitoring turret assemblies and tracking their interactions with other players or NPCs.
The Sentinel dashboard gives you visibility into who or what is scouting or attacking your assets throughout the EVE galaxy.
Displaying Turret Smart Assembly objects owned by the logged in wallet
Event history and threat intelligence from indexed on-chain turret events
Solar-system mapping for working around the location obfuscation in EVE, players can assign solar-systems to their network nodes
Galaxy plotting by network-node; assign solar systems to network-nodes to map turrets
Live operator view
NOTE: This app required PriorityTargetUpdateEvent s which are not yet published on-chain. To emulate them, the app has mock data loaded at https://ef-sentinel.xyz/demo
NOTE 2: This app reads and uses Stillness, but it is not a move contract so it does not have a special package ID.

An on-chain Mutual Defense Alliance (MDA) built in Sui Move for the **EVE x Sui Hackathon 2026**.
Players form a DAO to collectively defend territory. Smart Gates deny enemies, Smart Turrets prioritise attackers, and a shared armory arms members, all governed by on-chain proposals and DEFENSE token voting.
In EVE Frontier, solo players are vulnerable. Raiders attack bases, steal resources, and control chokepoints. Existing in-game tribe mechanics offer basic grouping, but lack enforceable rules, shared governance, or economic coordination. There's no way to collectively decide who's an enemy, pool defenses across multiple bases, or democratically manage an alliance's resources — until now.
Defense DAO turns EVE Frontier's three programmable Smart Assembly types into a fully autonomous alliance infrastructure:
Smart Gates become border checkpoints — alliance members pass freely, known enemies are blocked at the contract level, and non-members can pay a DEFENSE token toll to cross (revenue flows to the DAO treasury automatically)
Smart Turrets become intelligent sentries — attackers receive maximum targeting priority, flagged aggressors are engaged on sight, and every attack triggers an on-chain BaseAttackedEvent that feeds the community threat intelligence system
Smart Storage Units become communal armories — members deposit and withdraw shared items, enemies are denied access, all enforced by Move smart contracts
Autonomous Proposal Execution — The DaoAdminCap is stored inside the DefenseDAO shared object itself. When a proposal passes quorum, anyone can call execute_proposal and the DAO executes the action using its own capability — no human co-signer, no multisig, fully trustless.
Community Threat Intelligence — Any member can report an aggressor. Once an address accumulates enough independent reports (configurable threshold), it's automatically confirmed as an enemy across all DAO-controlled infrastructure. An off-chain event watcher bot bridges turret attack events to the reporting system, building the enemy registry organically from real combat data.
BehaviourChangeReason Workaround — The EVE Frontier world contracts restrict external pattern matching on the BehaviourChangeReason enum. We solved this by BCS-serializing the enum value and reading the ULEB128 variant index byte — a novel technique that enables extension code to differentiate between STARTED_ATTACK, STOPPED_ATTACK, and ENTERED behaviours without access to the enum's internal constructors.
Cross-Assembly Coordination — A single XAuth typed witness authorizes all three extension types. One DAO membership check propagates across gates, turrets, and storage units. Get flagged as an enemy? You're instantly locked out of every DAO-controlled structure in the game.


A crowdsourced intelligence platform for EVE Frontier pilots. Interactive star map, on-chain resource sighting reports with peer verification, route planner, item browser, cargo calculator, and capsuleer leaderboard — all powered by real game data and Sui blockchain attestation.
The Steve Show is a late night broadcast from the edge of the EVE Frontier universe,
powered by the EVE Frontier World API and Claude AI. Check out three channels to watch a new story every visit.
HISTORY CHANNEL — civilization stories from real tribes, real systems, real items.
BREAKING NEWS — player gossip. TBD on integrity.
ORACLE CHANNEL — intelligence and strategies through stories.
Basically, Steve talks. You watch. You (maybe) laugh. You read in between the lines. You learn things accidentally.
Built for entertaining players because what we say about what happens, how we tell it, and how we interpret it shapes the Frontier.