# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from dataclasses import dataclass import typing try: from genlayer import * except ModuleNotFoundError: from genlayer_py import * ZERO_ADDRESS = Address("0x0000000000000000000000000000000000000000") SUPPORTED_MODES = ("argue", "convince") @allow_storage @dataclass class PlayerProfile: name: str xp: u256 wins: u256 losses: u256 @allow_storage @dataclass class ArenaRoom: id: str owner: Address owner_name: str opponent: Address opponent_name: str mode: str category: str topic: str stance: str owner_argument: str opponent_argument: str status: str winner: Address owner_score: u16 opponent_score: u16 verdict_reasoning: str class VerdictArena(gl.Contract): profiles: TreeMap[Address, PlayerProfile] rooms: TreeMap[str, ArenaRoom] room_ids: DynArray[str] def __init__(self): pass @gl.public.write def register_profile(self, name: str): clean_name = name.strip() if len(clean_name) < 3: raise Exception("Profile names must be at least 3 characters.") if len(clean_name) > 24: raise Exception("Profile names must be 24 characters or fewer.") sender = gl.message.sender_address existing = self.profiles.get(sender, PlayerProfile("", u256(0), u256(0), u256(0))) self.profiles[sender] = PlayerProfile( clean_name, existing.xp, existing.wins, existing.losses, ) @gl.public.write def create_room(self, room_id: str, mode: str, category: str, topic: str, stance: str): sender = gl.message.sender_address self._require_profile(sender) normalized_id = room_id.strip().upper() normalized_mode = mode.strip().lower() normalized_topic = topic.strip() normalized_category = category.strip() normalized_stance = stance.strip() if not normalized_id: raise Exception("Room id is required.") if normalized_id in self.rooms: raise Exception("Room already exists.") if normalized_mode not in SUPPORTED_MODES: raise Exception("Only 'argue' and 'convince' are supported.") if len(normalized_topic) < 12: raise Exception("Topics must be at least 12 characters.") if normalized_mode == "convince" and not normalized_stance: raise Exception("Convince rooms require an opening stance.") profile = self.profiles[sender] self.rooms[normalized_id] = ArenaRoom( id=normalized_id, owner=sender, owner_name=profile.name, opponent=ZERO_ADDRESS, opponent_name="", mode=normalized_mode, category=normalized_category, topic=normalized_topic, stance=normalized_stance, owner_argument="", opponent_argument="", status="waiting", winner=ZERO_ADDRESS, owner_score=u16(0), opponent_score=u16(0), verdict_reasoning="", ) self.room_ids.append(normalized_id) @gl.public.write def join_room(self, room_id: str): sender = gl.message.sender_address self._require_profile(sender) room = self._require_room(room_id) if room.owner == sender: raise Exception("Room owner cannot join as the opponent.") if room.opponent != ZERO_ADDRESS: raise Exception("Room already has an opponent.") profile = self.profiles[sender] room.opponent = sender room.opponent_name = profile.name room.status = "active" if room.owner_argument and room.opponent_argument else "waiting" self.rooms[room.id] = room @gl.public.write def submit_argument(self, room_id: str, argument: str): sender = gl.message.sender_address room = self._require_room(room_id) text = argument.strip() if room.status == "resolved": raise Exception("Resolved rooms cannot be edited.") if len(text) < 40: raise Exception("Arguments must be at least 40 characters.") if sender == room.owner: room.owner_argument = text elif sender == room.opponent: room.opponent_argument = text else: raise Exception("Only room participants can submit arguments.") room.status = "active" if room.owner_argument and room.opponent_argument else "waiting" self.rooms[room.id] = room @gl.public.write def resolve_room(self, room_id: str): room = self._require_room(room_id) if room.opponent == ZERO_ADDRESS: raise Exception("Room cannot be judged until an opponent joins.") if not room.owner_argument or not room.opponent_argument: raise Exception("Both players must submit arguments before judging.") if room.status == "resolved": raise Exception("Room already has a verdict.") prompt = self._build_verdict_prompt(room) def leader_fn(): response = gl.nondet.exec_prompt(prompt, response_format="json") return self._normalize_verdict(response) def validator_fn(leader_result): if not isinstance(leader_result, gl.vm.Return): return False return self._is_valid_verdict(leader_result.calldata) verdict = gl.vm.run_nondet_unsafe(leader_fn, validator_fn) room.status = "resolved" room.winner = room.owner if verdict["winner"] == "owner" else room.opponent room.owner_score = verdict["owner_score"] room.opponent_score = verdict["opponent_score"] room.verdict_reasoning = verdict["reasoning"] self.rooms[room.id] = room owner_profile = self.profiles[room.owner] opponent_profile = self.profiles[room.opponent] if verdict["winner"] == "owner": owner_profile.wins += 1 owner_profile.xp += 15 opponent_profile.losses += 1 opponent_profile.xp = u256(max(0, int(opponent_profile.xp) - 5)) else: opponent_profile.wins += 1 opponent_profile.xp += 15 owner_profile.losses += 1 owner_profile.xp = u256(max(0, int(owner_profile.xp) - 5)) self.profiles[room.owner] = owner_profile self.profiles[room.opponent] = opponent_profile @gl.public.view def get_profile(self, user_address: str) -> TreeMap[str, typing.Any]: address = Address(user_address) return self.profiles.get(address, PlayerProfile("", u256(0), u256(0), u256(0))) @gl.public.view def get_room(self, room_id: str) -> TreeMap[str, typing.Any]: normalized_id = room_id.strip().upper() return self.rooms.get( normalized_id, ArenaRoom( id="", owner=ZERO_ADDRESS, owner_name="", opponent=ZERO_ADDRESS, opponent_name="", mode="argue", category="", topic="", stance="", owner_argument="", opponent_argument="", status="waiting", winner=ZERO_ADDRESS, owner_score=u16(0), opponent_score=u16(0), verdict_reasoning="", ), ) @gl.public.view def get_room_ids(self) -> DynArray[str]: return self.room_ids def _require_profile(self, address: Address): if address not in self.profiles or not self.profiles[address].name: raise Exception("Create a profile before interacting with Verdict Arena.") def _require_room(self, room_id: str) -> ArenaRoom: normalized_id = room_id.strip().upper() if normalized_id not in self.rooms: raise Exception("Room does not exist.") return self.rooms[normalized_id] def _build_verdict_prompt(self, room: ArenaRoom) -> str: stance_block = "" if room.stance: stance_block = f"\nArena stance to challenge:\n{room.stance}\n" return f""" You are evaluating a GenLayer debate room for Verdict Arena. Return valid JSON only with these keys: - "winner": either "owner" or "opponent" - "owner_score": integer 0-100 - "opponent_score": integer 0-100 - "reasoning": short explanation under 280 characters Rules: - Choose exactly one winner. No ties. - Reward clarity, evidence, structure, direct engagement, and relevance. - Penalize rambling, contradiction, shallow claims, and avoiding the prompt. - Scores must match the chosen winner. Mode: {room.mode} Category: {room.category} Topic: {room.topic} {stance_block} Owner ({room.owner_name}) submission: {room.owner_argument} Opponent ({room.opponent_name}) submission: {room.opponent_argument} """.strip() def _normalize_verdict(self, response: typing.Any) -> TreeMap[str, typing.Any]: if not isinstance(response, dict): raise Exception("LLM returned a non-dict verdict.") winner = str(response.get("winner", "")).strip().lower() if winner not in ("owner", "opponent"): raise Exception("Verdict winner must be 'owner' or 'opponent'.") owner_score = self._coerce_score(response.get("owner_score")) opponent_score = self._coerce_score(response.get("opponent_score")) reasoning = str(response.get("reasoning", "")).strip() if len(reasoning) < 16: raise Exception("Verdict reasoning is too short.") if winner == "owner" and owner_score <= opponent_score: owner_score = min(100, opponent_score + 1) if winner == "opponent" and opponent_score <= owner_score: opponent_score = min(100, owner_score + 1) return { "winner": winner, "owner_score": u16(owner_score), "opponent_score": u16(opponent_score), "reasoning": reasoning, } def _is_valid_verdict(self, verdict: typing.Any) -> bool: if not isinstance(verdict, dict): return False winner = verdict.get("winner") owner_score = verdict.get("owner_score") opponent_score = verdict.get("opponent_score") reasoning = verdict.get("reasoning") if winner not in ("owner", "opponent"): return False if not isinstance(reasoning, str) or len(reasoning.strip()) < 16: return False if not isinstance(owner_score, int) or not isinstance(opponent_score, int): return False if owner_score < 0 or owner_score > 100 or opponent_score < 0 or opponent_score > 100: return False if winner == "owner" and owner_score <= opponent_score: return False if winner == "opponent" and opponent_score <= owner_score: return False return True def _coerce_score(self, raw_score: typing.Any) -> int: try: score = int(round(float(str(raw_score).strip()))) except (ValueError, TypeError): raise Exception("Verdict score must be numeric.") if score < 0 or score > 100: raise Exception("Verdict scores must be between 0 and 100.") return score