# { "Depends": "py-genlayer:test" } import json from dataclasses import dataclass from genlayer import * # ── Challenge theme sets (rotated weekly via seed) ────────────────────────── CHALLENGES = [ [ "Write a prompt that generates the most creative haiku about decentralization", "Write a prompt that produces the most convincing argument for why AI needs consensus", "Write a prompt that creates the funniest story about validators disagreeing", ], [ "Write a prompt that generates the best metaphor for blockchain technology", "Write a prompt that produces the most insightful analysis of digital trust", "Write a prompt that creates the most engaging tweet about Web3", ], [ "Write a prompt that generates the most poetic description of a smart contract", "Write a prompt that produces the best ELI5 explanation of consensus mechanisms", "Write a prompt that creates the most creative use case for AI on-chain", ], [ "Write a prompt that makes an LLM produce the wittiest one-liner about crypto culture", "Write a prompt that generates the most thought-provoking question about machine intelligence", "Write a prompt that creates the most compelling pitch for a decentralized social network", ], [ "Write a prompt that generates the most vivid analogy for how validators reach agreement", "Write a prompt that produces the most entertaining dialogue between two AIs debating free will", "Write a prompt that creates the best recipe metaphor for building a dApp", ], [ "Write a prompt that generates the most inspiring vision of the internet in 2035", "Write a prompt that produces the most creative acronym for BLOCKCHAIN with definitions", "Write a prompt that creates the most dramatic movie trailer synopsis for a film about AI consensus", ], ] TOTAL_ROUNDS: int = 3 MIN_PLAYERS: int = 2 MAX_PLAYERS_LIMIT: int = 6 # XP rewards by final placement XP_REWARDS = [100, 60, 30, 10, 10, 10] # ── Storage data classes ──────────────────────────────────────────────────── @allow_storage @dataclass class RoomPlayer: address: Address prompt: str round_score: u32 total_score: u32 has_submitted: bool @allow_storage @dataclass class Room: room_id: u32 creator: Address current_round: u32 # 0=lobby, 1-3=active rounds, 4=finished challenge_seed: u32 player_count: u32 max_players: u32 prompts_submitted: u32 is_scored: bool # ── Main Contract ─────────────────────────────────────────────────────────── class PromptDuel(gl.Contract): next_room_id: u32 rooms: TreeMap[u32, Room] room_players: TreeMap[u32, TreeMap[u32, RoomPlayer]] room_player_index: TreeMap[u32, TreeMap[Address, u32]] global_xp: TreeMap[Address, u32] challenge_seed: u32 def __init__(self, seed: u32): self.next_room_id = 0 self.challenge_seed = seed # ── Room Management ───────────────────────────────────────────────── @gl.public.write def create_room(self, max_players: u32) -> u32: if max_players < MIN_PLAYERS or max_players > MAX_PLAYERS_LIMIT: raise Exception( f"max_players must be between {MIN_PLAYERS} and {MAX_PLAYERS_LIMIT}" ) room_id = self.next_room_id self.next_room_id += 1 self.rooms[room_id] = Room( room_id=room_id, creator=gl.message.sender_account, current_round=0, challenge_seed=self.challenge_seed, player_count=1, max_players=max_players, prompts_submitted=0, is_scored=False, ) self.room_players[room_id][0] = RoomPlayer( address=gl.message.sender_account, prompt="", round_score=0, total_score=0, has_submitted=False, ) self.room_player_index[room_id][gl.message.sender_account] = 0 return room_id @gl.public.write def join_room(self, room_id: u32): room = self.rooms[room_id] if room.current_round != 0: raise Exception("Game already started") if room.player_count >= room.max_players: raise Exception("Room is full") sender = gl.message.sender_account # Check not already in room existing = self.room_player_index[room_id].get(sender, None) if existing is not None: raise Exception("Already in this room") idx = room.player_count self.room_players[room_id][idx] = RoomPlayer( address=sender, prompt="", round_score=0, total_score=0, has_submitted=False, ) self.room_player_index[room_id][sender] = idx self.rooms[room_id].player_count = idx + 1 @gl.public.write def start_game(self, room_id: u32): room = self.rooms[room_id] if room.creator != gl.message.sender_account: raise Exception("Only the room creator can start the game") if room.current_round != 0: raise Exception("Game already started") if room.player_count < MIN_PLAYERS: raise Exception(f"Need at least {MIN_PLAYERS} players to start") self.rooms[room_id].current_round = 1 self.rooms[room_id].prompts_submitted = 0 self.rooms[room_id].is_scored = False # ── Gameplay ──────────────────────────────────────────────────────── @gl.public.write def submit_prompt(self, room_id: u32, prompt: str): room = self.rooms[room_id] if room.current_round < 1 or room.current_round > TOTAL_ROUNDS: raise Exception("Game is not in an active round") sender = gl.message.sender_account player_idx_val = self.room_player_index[room_id].get(sender, None) if player_idx_val is None: raise Exception("Not a player in this room") player_idx = player_idx_val player = self.room_players[room_id][player_idx] if player.has_submitted: raise Exception("Already submitted a prompt this round") if len(prompt.strip()) == 0: raise Exception("Prompt cannot be empty") if len(prompt) > 1000: raise Exception("Prompt must be 1000 characters or fewer") self.room_players[room_id][player_idx].prompt = prompt self.room_players[room_id][player_idx].has_submitted = True self.rooms[room_id].prompts_submitted = room.prompts_submitted + 1 @gl.public.write def score_round(self, room_id: u32): room = gl.storage.copy_to_memory(self.rooms[room_id]) if room.current_round < 1 or room.current_round > TOTAL_ROUNDS: raise Exception("No active round to score") if room.is_scored: raise Exception("Round already scored") if room.prompts_submitted < room.player_count: raise Exception("Not all players have submitted prompts yet") # Gather all prompts (must copy to memory for nondet block) challenge = _get_challenge_text(room.challenge_seed, room.current_round) player_prompts = [] for i in range(room.player_count): p = gl.storage.copy_to_memory(self.room_players[room_id][i]) player_prompts.append({"index": i, "prompt": p.prompt}) prompts_text = "\n".join( [f"Player {pp['index']}: {pp['prompt']}" for pp in player_prompts] ) num_players = room.player_count # ── LLM Scoring via Optimistic Democracy consensus ────────── scoring_result = gl.eq_principle.prompt_non_comparative( input=prompts_text, task=f"""You are the judge of a Prompt Duel competition. The challenge was: "{challenge}" {num_players} players each submitted a prompt. Your job is to score each player's prompt from 0 to 100 based on these criteria: - Creativity (30%): How original and clever is the prompt? - Relevance (30%): How well does the prompt address the challenge? - Quality (40%): How good would the LLM output be if this prompt were used? Return ONLY valid JSON in this exact format: {{"scores": [{{"player": 0, "score": , "reason": ""}}, ...]}} You must score every player. Be fair and objective.""", criteria="""Scores must be integers between 0 and 100 inclusive. Every player listed in the input must have exactly one score entry. Output must be valid JSON with a top-level "scores" array. Each entry must have "player" (int), "score" (int), and "reason" (string). Scoring should reflect genuine prompt engineering quality. Prompts of similar quality should receive scores within 10 points of each other. Do not favor any player based on submission order.""", ) # Parse scores and update state results = json.loads(scoring_result) for entry in results["scores"]: idx = entry["player"] score = entry["score"] self.room_players[room_id][idx].round_score = score self.room_players[room_id][idx].total_score += score self.rooms[room_id].is_scored = True @gl.public.write def advance_round(self, room_id: u32): room = self.rooms[room_id] if room.current_round < 1 or room.current_round > TOTAL_ROUNDS: raise Exception("No active round to advance from") if not room.is_scored: raise Exception("Current round has not been scored yet") if room.current_round >= TOTAL_ROUNDS: # Game over — distribute XP self._distribute_xp(room_id, room.player_count) self.rooms[room_id].current_round = TOTAL_ROUNDS + 1 # = 4 = finished else: # Move to next round self.rooms[room_id].current_round = room.current_round + 1 self.rooms[room_id].prompts_submitted = 0 self.rooms[room_id].is_scored = False # Reset per-round player state for i in range(room.player_count): self.room_players[room_id][i].prompt = "" self.room_players[room_id][i].round_score = 0 self.room_players[room_id][i].has_submitted = False def _distribute_xp(self, room_id: u32, player_count: u32): # Collect (total_score, index) and sort descending scores = [] for i in range(player_count): p = self.room_players[room_id][i] scores.append((p.total_score, i)) # Simple insertion sort (max 6 players) for i in range(1, len(scores)): key = scores[i] j = i - 1 while j >= 0 and scores[j][0] < key[0]: scores[j + 1] = scores[j] j -= 1 scores[j + 1] = key # Award XP for rank, (total_score, player_idx) in enumerate(scores): player = self.room_players[room_id][player_idx] xp = XP_REWARDS[rank] if rank < len(XP_REWARDS) else 10 current_xp = self.global_xp.get(player.address, 0) self.global_xp[player.address] = current_xp + xp # ── Admin ─────────────────────────────────────────────────────────── @gl.public.write def update_seed(self, new_seed: u32): self.challenge_seed = new_seed # ── View Methods ──────────────────────────────────────────────────── @gl.public.view def get_room(self, room_id: u32) -> dict: room = self.rooms[room_id] return { "room_id": room.room_id, "creator": str(room.creator), "current_round": room.current_round, "challenge_seed": room.challenge_seed, "player_count": room.player_count, "max_players": room.max_players, "prompts_submitted": room.prompts_submitted, "is_scored": room.is_scored, } @gl.public.view def get_room_players(self, room_id: u32) -> list: room = self.rooms[room_id] players = [] for i in range(room.player_count): p = self.room_players[room_id][i] players.append( { "index": i, "address": str(p.address), "prompt": p.prompt if room.is_scored else "", "round_score": p.round_score, "total_score": p.total_score, "has_submitted": p.has_submitted, } ) return players @gl.public.view def get_challenge(self, room_id: u32) -> str: room = self.rooms[room_id] if room.current_round < 1 or room.current_round > TOTAL_ROUNDS: return "" return _get_challenge_text(room.challenge_seed, room.current_round) @gl.public.view def get_leaderboard(self) -> list: entries = [] for address in self.global_xp: xp = self.global_xp[address] entries.append({"address": str(address), "xp": xp}) # Sort by XP descending for i in range(1, len(entries)): key = entries[i] j = i - 1 while j >= 0 and entries[j]["xp"] < key["xp"]: entries[j + 1] = entries[j] j -= 1 entries[j + 1] = key return entries[:20] # top 20 @gl.public.view def get_total_rooms(self) -> u32: return self.next_room_id @gl.public.view def get_player_xp(self, address: Address) -> u32: return self.global_xp.get(address, 0) # ── Helper (module-level, deterministic) ──────────────────────────────────── def _get_challenge_text(seed: u32, round_num: u32) -> str: theme_idx = seed % len(CHALLENGES) round_idx = round_num - 1 if round_idx < 0 or round_idx >= len(CHALLENGES[theme_idx]): return "Write the most creative prompt you can think of" return CHALLENGES[theme_idx][round_idx]