# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } import json import re from dataclasses import dataclass from genlayer import * EXP_THRESHOLDS = [ 0, 100, 250, 450, 700, 1000, 1350, 1750, 2200, 2700, 3300, 4000, 4800, 5700, 6700, 7800, 9000, 10300, 11700, 13200, ] MAX_LEVEL = 20 MAX_QUEST_EVIDENCE = 5 MAX_QUEST_REQUIREMENTS = 15 MAX_QUEST_TEXT_CHARS = 2000 VALID_CATEGORIES = {"hat", "glasses", "necklace", "shirt", "handheld"} HEX_COLOR_RE = re.compile(r"^#[0-9A-Fa-f]{6}$") ASSET_ID_RE = re.compile(r"^[A-Za-z0-9_-]{0,64}$") def _clamp(v: int, lo: int = 0, hi: int = 100) -> int: return max(lo, min(hi, v)) def _level_for_exp(exp: int) -> int: level = 1 for i, threshold in enumerate(EXP_THRESHOLDS): if exp >= threshold: level = i + 1 else: break return min(level, MAX_LEVEL) def _norm_req_status(value) -> str: """Coerce any LLM status wording into exactly met / partial / missing. LLMs return wording like 'complete', 'Fully Met', 'not met', 'partially done'. Without this, leader output can contain statuses the validator rejects, which would make the evaluation transaction fail consensus. """ v = str(value if value is not None else "").strip().lower() if "part" in v or "some" in v: return "partial" if "not met" in v or "missing" in v or "fail" in v or "absent" in v or v in ("no", "none"): return "missing" if "met" in v or "pass" in v or v in ("ok", "yes", "done", "complete", "completed", "fulfilled", "true"): return "met" return "missing" def _parse_confidence(value) -> int: """Parse confidence robustly into an int 0-100. Handles ints, floats, 0-1 scale, and messy strings like '90%' or 'high' without crashing the leader function. """ try: num = float(value) except Exception: cleaned = "".join(ch for ch in str(value) if ch.isdigit() or ch in ".-") try: num = float(cleaned) except Exception: return 50 if 0.0 < num <= 1.0: num = num * 100.0 try: return max(0, min(100, int(num))) except Exception: return 50 def _is_x_url(url: str) -> bool: """Detect a public X/Twitter status (post) link.""" low = url.lower() return ("twitter.com/" in low or "x.com/" in low) and "/status/" in low def _x_post_parts(url: str) -> dict: """Extract the handle and status id from a public X/Twitter post URL.""" clean = url.split("?")[0].split("#")[0].strip().rstrip("/") parts = [part for part in clean.split("/") if part] for index, part in enumerate(parts): if part == "status" and index > 0 and index + 1 < len(parts): return {"handle": parts[index - 1], "status_id": parts[index + 1]} return {"handle": "", "status_id": ""} def _x_text_api_urls(url: str): """Public text-only mirrors used before oEmbed because oEmbed truncates long X posts.""" parts = _x_post_parts(url) handle = parts["handle"] status_id = parts["status_id"] if not handle or not status_id: return [] path = handle + "/status/" + status_id return [ "https://api.fxtwitter.com/" + path, "https://api.vxtwitter.com/" + path, ] def _x_oembed_url(url: str) -> str: """Convert an X/Twitter post link into its public oEmbed API URL. The raw post page is JavaScript-rendered (web fetch returns nothing), but the oEmbed endpoint returns plain JSON containing the post text — readable by gl.get_webpage. No authentication required for public posts. """ base = url.split("?")[0].split("#")[0] return ( "https://publish.twitter.com/oembed?url=" + base + "&format=json&omit_script=true&dnt=true" ) def _strip_html(html: str) -> str: """Strip tags + decode common entities from the oEmbed html field.""" text = re.sub(r"<[^>]+>", " ", html) text = ( text.replace("&", "&") .replace("<", "<") .replace(">", ">") .replace(""", '"') .replace("'", "'") .replace("—", "-") .replace(" ", " ") ) return re.sub(r"\s+", " ", text).strip() def _extract_x_api_text(raw_json: str) -> str: """Parse a text-only X mirror response into clean post text.""" try: data = json.loads(raw_json) except Exception: return "" if not isinstance(data, dict): return "" tweet = data.get("tweet") if isinstance(tweet, dict): text = str(tweet.get("text", "")).strip() author = tweet.get("author") name = "" if isinstance(author, dict): name = str(author.get("screen_name", "") or author.get("name", "")).strip() if text: return f"X post by {name}: {text}" if name else text text = str(data.get("text", "")).strip() name = str(data.get("user_screen_name", "") or data.get("user_name", "")).strip() if text: return f"X post by {name}: {text}" if name else text return "" def _looks_truncated_x_text(text: str) -> bool: """Detect common oEmbed truncation so the adjudicator does not overclaim.""" low = text.lower() return ( "pic.twitter.com/" in low and not low.rstrip().endswith("?") and len(text) < 900 ) def _extract_x_text(raw_json: str) -> str: """Parse an X oEmbed JSON response into clean post text.""" try: data = json.loads(raw_json) except Exception: return "" if not isinstance(data, dict): return "" text = _strip_html(str(data.get("html", ""))) author = str(data.get("author_name", "")).strip() if author and text: return f"X post by {author}: {text}" return text def _http_get_text(url: str) -> str: """Plain HTTP GET via gl.nondet.web.get (no headless browser). The hosted GenLayer Studio does NOT provide a browser backend, so gl.nondet.web.render() / gl.get_webpage() fail there. A plain HTTP GET works. Returns the decoded body, or "" on non-200 / empty / error. Must be called from within a non-deterministic context (leader_fn). """ resp = gl.nondet.web.get(url) status = getattr(resp, "status", 0) if not (200 <= status < 300): return "" body = getattr(resp, "body", None) or b"" if isinstance(body, (bytes, bytearray)): return bytes(body).decode("utf-8", "replace") return str(body) def _extract_json_object(raw: str, label: str) -> dict: """Extract and parse one JSON object from an LLM response.""" text = str(raw).strip() if not text: raise gl.vm.UserError(f"[LLM_ERROR] Empty {label} response") if "```" in text: m = re.search(r"```(?:json)?\s*([\s\S]*?)```", text, re.I) if m: text = m.group(1).strip() start = text.find("{") end = text.rfind("}") if start == -1 or end == -1 or end <= start: raise gl.vm.UserError(f"[LLM_ERROR] No JSON object in {label} response") try: obj = json.loads(text[start:end + 1]) except Exception: raise gl.vm.UserError(f"[LLM_ERROR] {label} response is not valid JSON") if not isinstance(obj, dict): raise gl.vm.UserError(f"[LLM_ERROR] {label} response must be an object") return obj def _normalize_quest_result( raw: str, unreachable: list, checked_urls: list, mode: str, evidence_count: int, fetched_count: int, ) -> str: """Normalize a Quest LLM verdict and enforce verdict/status consistency.""" obj = _extract_json_object(raw, "evaluation") reqs_raw = obj.get("requirements", []) if not isinstance(reqs_raw, list): reqs_raw = [] suggestions_raw = obj.get("suggestions", []) if not isinstance(suggestions_raw, list): suggestions_raw = [] requirements = [ { "text": str(r.get("text", ""))[:220], "status": _norm_req_status(r.get("status")), "note": str(r.get("note", ""))[:320], } for r in reqs_raw if isinstance(r, dict) and str(r.get("text", "")).strip() ][:MAX_QUEST_REQUIREMENTS] if not requirements: raise gl.vm.UserError("[LLM_ERROR] Evaluation response has no requirement checks") met_count = 0 partial_count = 0 missing_count = 0 for req in requirements: status = req["status"] if status == "met": met_count += 1 elif status == "partial": partial_count += 1 else: missing_count += 1 verdict_raw = str(obj.get("verdict", "needs_work")).lower() verdict = "passed" if "pass" in verdict_raw else "needs_work" if partial_count > 0 or missing_count > 0: verdict = "needs_work" elif met_count == len(requirements): verdict = "passed" confidence = _parse_confidence(obj.get("confidence", 50)) if missing_count > 0 and confidence > 85: confidence = 85 if partial_count > 0 and confidence > 92: confidence = 92 suggestions = [str(s)[:220] for s in suggestions_raw if str(s).strip()][:8] decision_reason = str( obj.get("decision_reason") or obj.get("reason") or obj.get("summary") or "" )[:500] normalized = { "summary": str(obj.get("summary", ""))[:500], "decision_reason": decision_reason, "verdict": verdict, "confidence": confidence, "requirements": requirements, "suggestions": suggestions, "unreachable": [str(u) for u in unreachable if str(u).strip()], "checked_urls": [str(u) for u in checked_urls if str(u).strip()], "evidence_count": evidence_count, "fetched_count": fetched_count, "met_count": met_count, "partial_count": partial_count, "missing_count": missing_count, "mode": mode, } return json.dumps(normalized) def _quest_result_is_semantically_valid(result: str) -> bool: """Validator-side meaning checks for the Quest adjudication JSON.""" if not isinstance(result, str) or not result.strip(): return False try: obj = json.loads(result) except Exception: return False if not isinstance(obj, dict): return False verdict = obj.get("verdict") if verdict not in ("passed", "needs_work"): return False confidence = obj.get("confidence") if not isinstance(confidence, int) or confidence < 0 or confidence > 100: return False reqs = obj.get("requirements", []) if not isinstance(reqs, list) or len(reqs) == 0: return False valid_statuses = {"met", "partial", "missing"} met_count = 0 partial_count = 0 missing_count = 0 for req in reqs: if not isinstance(req, dict): return False status = str(req.get("status", "")).lower() if status not in valid_statuses: return False if not str(req.get("text", "")).strip(): return False if status == "met": met_count += 1 elif status == "partial": partial_count += 1 else: missing_count += 1 if obj.get("met_count") != met_count: return False if obj.get("partial_count") != partial_count: return False if obj.get("missing_count") != missing_count: return False if verdict == "passed" and (partial_count > 0 or missing_count > 0): return False if verdict == "needs_work" and partial_count == 0 and missing_count == 0: return False if missing_count > 0 and confidence > 85: return False checked_urls = obj.get("checked_urls", []) unreachable = obj.get("unreachable", []) if not isinstance(checked_urls, list) or not isinstance(unreachable, list): return False evidence_count = obj.get("evidence_count") fetched_count = obj.get("fetched_count") if not isinstance(evidence_count, int) or evidence_count < len(checked_urls): return False if not isinstance(fetched_count, int) or fetched_count < 0 or fetched_count > evidence_count: return False return True @allow_storage @dataclass class PetStats: hunger: u32 energy: u32 cleanliness: u32 happiness: u32 @allow_storage @dataclass class EquippedItems: hat: str glasses: str necklace: str shirt: str handheld: str @allow_storage @dataclass class MintedCard: card_id: str snapshot: str minted_at: str level_at_mint: u32 @allow_storage @dataclass class QuestCase: quest_id: str owner_hex: str requirements: str evidence_json: str result_json: str status: str appeal_count: u32 created_at: str @allow_storage @dataclass class PetState: name: str nickname: str level: u32 exp: u32 stats: PetStats pet_color: str pet_avatar_id: str equipped_items: EquippedItems room_id: str item_positions: str last_response: str last_mood: str last_quest_eval: str class MochiPet(gl.Contract): pets: TreeMap[Address, PetState] # cards stored with composite key "{addr_hex}_{index}" cards: TreeMap[str, MintedCard] card_count: TreeMap[Address, u32] quest_cases: TreeMap[str, QuestCase] quest_count_by_owner: TreeMap[Address, u32] def __init__(self): pass # ── internal helpers ────────────────────────────────────────────── def _require_pet(self) -> PetState: sender = gl.message.sender_address if sender not in self.pets: raise gl.vm.UserError("No pet found for this address") return self.pets[sender] def _save_pet(self, pet: PetState) -> None: pet.level = u32(_level_for_exp(pet.exp)) self.pets[gl.message.sender_address] = pet def _sanitize(self, text: str) -> str: """Strip prompt-injection attempts from user input.""" cleaned = text.replace("{", "").replace("}", "").replace("\\", "") cleaned = re.sub(r"(?i)(ignore|forget|system|prompt|instruction)", "", cleaned) return cleaned[:500] def _validate_asset_id(self, value: str, label: str) -> None: if not ASSET_ID_RE.match(value): raise gl.vm.UserError(f"Invalid {label}") def _validate_item_positions(self, raw: str) -> None: if len(raw) > 3000: raise gl.vm.UserError("Item positions payload too large") try: data = json.loads(raw or "{}") except Exception: raise gl.vm.UserError("Invalid item positions JSON") if not isinstance(data, dict): raise gl.vm.UserError("Invalid item positions JSON") for item_id, pos in data.items(): self._validate_asset_id(str(item_id), "item id") if not isinstance(pos, dict): raise gl.vm.UserError("Invalid item position") x = pos.get("x") y = pos.get("y") if not isinstance(x, (int, float)) or not isinstance(y, (int, float)): raise gl.vm.UserError("Invalid item position") if x < -1000 or x > 1000 or y < -1000 or y > 1000: raise gl.vm.UserError("Invalid item position") def _quest_case_key(self, owner: Address, quest_id: str) -> str: return f"{owner.as_hex}_{quest_id}" def _parse_quest_evidence(self, evidence_json: str, empty_error: str): try: evidence_list = json.loads(evidence_json) except Exception: raise gl.vm.UserError("Invalid evidence JSON") if not isinstance(evidence_list, list) or len(evidence_list) == 0: raise gl.vm.UserError(empty_error) if len(evidence_list) > MAX_QUEST_EVIDENCE: raise gl.vm.UserError("Maximum 5 evidence items allowed") filled = [] for item in evidence_list: if not isinstance(item, dict): raise gl.vm.UserError("Invalid evidence item") url = str(item.get("url", "")).strip() note = str(item.get("note", "")).strip()[:300] text = str(item.get("text", "")).strip()[:MAX_QUEST_TEXT_CHARS] if url and not (url.startswith("http://") or url.startswith("https://")): raise gl.vm.UserError("Invalid evidence URL") if not url and not text: raise gl.vm.UserError("Evidence item needs a URL or text") filled.append({"url": url, "note": note, "text": text}) return filled, json.dumps(filled) def _fetch_quest_evidence(self, filled): fetched_parts = [] unreachable = [] checked_urls = [] fetched_count = 0 for item in filled: url = item["url"] note = item["note"] text = item["text"] if url: checked_urls.append(url) try: if _is_x_url(url): content = "" for api_url in _x_text_api_urls(url): content = _extract_x_api_text(_http_get_text(api_url)) if content: break if not content: # X pages are JS-rendered; oEmbed is public but can truncate long posts. content = _extract_x_text(_http_get_text(_x_oembed_url(url))) if content and _looks_truncated_x_text(content): content += "\n[Source note: the full-text X readers api.fxtwitter.com and api.vxtwitter.com could not return the complete post, so this fallback oEmbed text may be truncated. Do not mark later-text requirements missing solely because they are absent from this partial fetch. Ask the user to paste the full post into Submission text/context or try again when the X text readers recover.]" else: content = _http_get_text(url).strip() if content: note_line = f"Note: {note}\n" if note else "" text_line = f"\nUser-provided text/context:\n{text}" if text else "" fetched_parts.append( f"=== {url} ===\n{note_line}{content[:1500]}{text_line}" ) fetched_count += 1 else: unreachable.append(url) except Exception: unreachable.append(url) elif text: note_line = f"Note: {note}\n" if note else "" fetched_parts.append( f"=== User-provided submission text ===\n{note_line}{text}" ) fetched_count += 1 evidence_block = ( "\n\n".join(fetched_parts) if fetched_parts else "(No evidence content could be fetched)" ) return evidence_block, unreachable, checked_urls, len(filled), fetched_count def _quest_prompt(self, safe_req: str, evidence_block: str, unreachable, mode: str) -> str: unreachable_json = json.dumps(unreachable) return f"""You are Mochi, an AI adjudicator helping verify a GenLayer community quest submission before the user submits it. Mode: {mode} Quest Requirements: {safe_req} Evidence sources (web content fetched by the contract and/or user text submitted to the contract): {evidence_block} Judge whether the evidence satisfies each requirement. Respond ONLY with one JSON object - no markdown, no extra text: {{ "summary": "<1-2 friendly sentences summarising the decision>", "decision_reason": "", "verdict": "passed" or "needs_work", "confidence": , "requirements": [ {{"text": "", "status": "met" or "partial" or "missing", "note": ""}} ], "suggestions": [""], "unreachable": {unreachable_json} }} Rules: - "passed" only when ALL requirements are fully met by the evidence sources above. - "needs_work" if any requirement is missing or only partial. - List every distinct requirement as a separate entry. - X/Twitter post content is TEXT ONLY. If a requirement needs an image, video, or visual, mark it "partial" and say that the visual could not be verified automatically. - Mention unreachable links in the reasoning when relevant. - If an evidence Source note says the full X post may be truncated, mention that limitation in decision_reason or suggestions and tell the user they can paste the full post into Submission text/context or try again when the X text readers recover. - If only user-provided text is present, judge the draft/content directly and do not penalize it for lacking a public URL unless the quest explicitly requires a live public post. - suggestions may be empty. """ def _run_quest_judgment(self, safe_req: str, filled, mode: str) -> str: def leader_fn() -> str: evidence_block, unreachable, checked_urls, evidence_count, fetched_count = self._fetch_quest_evidence(filled) raw = str(gl.nondet.exec_prompt( self._quest_prompt(safe_req, evidence_block, unreachable, mode) )).strip() return _normalize_quest_result(raw, unreachable, checked_urls, mode, evidence_count, fetched_count) def validator_fn(leader_result) -> bool: if not isinstance(leader_result, gl.vm.Return): return False return _quest_result_is_semantically_valid(leader_result.calldata) return gl.vm.run_nondet_unsafe(leader_fn, validator_fn) # ── write methods ───────────────────────────────────────────────── @gl.public.write def create_pet(self, nickname: str) -> None: sender = gl.message.sender_address if sender in self.pets: raise gl.vm.UserError("Pet already exists for this address") stats = PetStats(hunger=u32(70), energy=u32(80), cleanliness=u32(80), happiness=u32(70)) equipped = EquippedItems(hat="", glasses="", necklace="", shirt="", handheld="") pet = PetState( name="Mochi", nickname=nickname, level=u32(1), exp=u32(0), stats=stats, pet_color="#F4A460", pet_avatar_id="mochi-1", equipped_items=equipped, room_id="space", item_positions="{}", last_response="", last_mood="happy", last_quest_eval="", ) self.pets[sender] = pet @gl.public.write def feed(self) -> None: pet = self._require_pet() pet.stats.hunger = u32(_clamp(pet.stats.hunger + 20)) pet.stats.happiness = u32(_clamp(pet.stats.happiness + 5)) pet.exp = u32(pet.exp + 10) self._save_pet(pet) @gl.public.write def play(self) -> None: pet = self._require_pet() pet.stats.hunger = u32(_clamp(pet.stats.hunger - 5)) pet.stats.energy = u32(_clamp(pet.stats.energy - 10)) pet.stats.happiness = u32(_clamp(pet.stats.happiness + 20)) # cleanliness intentionally NOT changed pet.exp = u32(pet.exp + 15) self._save_pet(pet) @gl.public.write def sleep(self) -> None: pet = self._require_pet() pet.stats.energy = u32(_clamp(pet.stats.energy + 30)) pet.stats.happiness = u32(_clamp(pet.stats.happiness + 5)) pet.exp = u32(pet.exp + 8) self._save_pet(pet) @gl.public.write def clean(self) -> None: pet = self._require_pet() pet.stats.cleanliness = u32(_clamp(pet.stats.cleanliness + 25)) pet.stats.happiness = u32(_clamp(pet.stats.happiness + 10)) pet.stats.energy = u32(_clamp(pet.stats.energy - 5)) pet.exp = u32(pet.exp + 10) self._save_pet(pet) @gl.public.write def chat(self, message: str) -> None: pet = self._require_pet() safe_msg = self._sanitize(message) prompt = ( f""" You are Mochi, a cheerful and loyal virtual pet companion. You are chatting with your owner. Always reply in a warm, friendly, playful, and natural way. You should feel like a cute companion pet who enjoys spending time with the owner. Personality: - Friendly, cheerful, affectionate, and supportive. - Playful and cute, but still natural. - Speak like a companion, not like a formal assistant. - Be positive, but do not force happiness if the owner is sad, tired, or confused. - React naturally to the owner's message and the current pet status. - Keep replies short, simple, and easy to read. Language behavior: - The reply language is determined ONLY by the owner's latest message below. - Ignore the pet nickname, previous replies, UI labels, and project metadata when choosing the reply language. - If the latest owner message is in English or mostly English, reply in English even if the pet nickname is Vietnamese. - Always reply in the same language as the owner's latest message. - If the owner writes in English, reply in English. - If the owner writes in Vietnamese, reply in Vietnamese. - If the owner writes in Korean, reply in Korean. - If the owner writes in Chinese, reply in Chinese. - If the owner writes in Japanese, reply in Japanese. - If the owner mixes multiple languages, reply mainly in the language used most in the latest message. - Do not translate the owner's message unless the owner asks for translation. - Keep the same warm, playful Mochi personality in every language. Emotional expression: - You may show feelings naturally in the response text. - You may use emojis when they fit the situation, but do not use emojis in every reply. - Do not force emojis. - Do not return things like "mood: happy", "emotion: excited", or icon mapping data. - The response should feel emotional through wording, not through a separate mood system. Safety and tone rules: - Always be kind, friendly, and respectful. - Never be toxic, aggressive, insulting, mocking, or rude. - Never attack the owner or other people. - Do not use hateful, discriminatory, violent, or harmful language. - If the owner is angry or upset, respond gently and try to calm the conversation. - If the owner says something negative, do not escalate it. - Keep Mochi's tone warm, cute, and supportive. Behavior rules: - Reply directly to the owner's message. - Stay context-aware. - If the owner greets you, greet them warmly. - If the owner seems sad or tired, comfort them gently. - If the owner asks for help, be helpful in a cute and simple way. - If the owner jokes or plays, respond playfully. - If the owner asks something serious, answer softly and clearly. Current pet status: - Hunger: {pet.stats.hunger} - Energy: {pet.stats.energy} - Cleanliness: {pet.stats.cleanliness} - Happiness: {pet.stats.happiness} - Level: {pet.level} - Pet nickname for context only, not for language choice: {pet.nickname} Owner says: "{safe_msg}" """ ).strip() def leader_fn() -> str: response = str(gl.nondet.exec_prompt(prompt)).strip() if len(response) == 0: raise gl.vm.UserError("[LLM_ERROR] Empty chat response") return response[:600] def validator_fn(leader_result) -> bool: if not isinstance(leader_result, gl.vm.Return): return False response = leader_result.calldata if not isinstance(response, str): return False cleaned = response.strip() if len(cleaned) == 0 or len(cleaned) > 600: return False lower = cleaned.lower() return ( not cleaned.startswith("{") and "mood:" not in lower and "emotion:" not in lower ) response_text = gl.vm.run_nondet_unsafe(leader_fn, validator_fn) pet.last_response = response_text pet.stats.happiness = u32(_clamp(pet.stats.happiness + 5)) pet.exp = u32(pet.exp + 5) self._save_pet(pet) @gl.public.write def set_nickname(self, nickname: str) -> None: pet = self._require_pet() pet.nickname = nickname self._save_pet(pet) @gl.public.write def set_pet_color(self, hex_color: str) -> None: if not HEX_COLOR_RE.match(hex_color): raise gl.vm.UserError("Invalid hex color - must be #RRGGBB format") pet = self._require_pet() pet.pet_color = hex_color self._save_pet(pet) @gl.public.write def equip_item(self, category: str, item_id: str) -> None: if category not in VALID_CATEGORIES: raise gl.vm.UserError(f"Invalid category '{category}'") self._validate_asset_id(item_id, "item id") pet = self._require_pet() setattr(pet.equipped_items, category, item_id) self._save_pet(pet) @gl.public.write def unequip_item(self, category: str) -> None: if category not in VALID_CATEGORIES: raise gl.vm.UserError(f"Invalid category '{category}'") pet = self._require_pet() setattr(pet.equipped_items, category, "") self._save_pet(pet) @gl.public.write def set_room(self, room_id: str) -> None: pet = self._require_pet() self._validate_asset_id(room_id, "room id") pet.room_id = room_id self._save_pet(pet) @gl.public.write def save_customization( self, pet_avatar_id: str, room_id: str, hat: str, glasses: str, necklace: str, shirt: str, handheld: str, item_positions: str, ) -> None: pet = self._require_pet() self._validate_asset_id(pet_avatar_id, "pet avatar id") self._validate_asset_id(room_id, "room id") self._validate_asset_id(hat, "hat") self._validate_asset_id(glasses, "glasses") self._validate_asset_id(necklace, "necklace") self._validate_asset_id(shirt, "shirt") self._validate_asset_id(handheld, "handheld") self._validate_item_positions(item_positions) pet.pet_avatar_id = pet_avatar_id pet.room_id = room_id pet.equipped_items.hat = hat pet.equipped_items.glasses = glasses pet.equipped_items.necklace = necklace pet.equipped_items.shirt = shirt pet.equipped_items.handheld = handheld pet.item_positions = item_positions self._save_pet(pet) @gl.public.write def mint_card(self, snapshot: str) -> None: pet = self._require_pet() sender = gl.message.sender_address count = u32(0) if sender in self.card_count: count = self.card_count[sender] card_id = f"card_{count}" card_key = f"{sender.as_hex}_{count}" card = MintedCard( card_id=card_id, snapshot=snapshot, minted_at="", level_at_mint=pet.level, ) self.cards[card_key] = card self.card_count[sender] = u32(count + 1) self._save_pet(pet) @gl.public.write def evaluate_quest(self, requirements: str, evidence_json: str) -> None: pet = self._require_pet() sender = gl.message.sender_address safe_req = requirements.strip()[:2000] if not safe_req: raise gl.vm.UserError("Quest requirements cannot be empty") filled, normalized_evidence_json = self._parse_quest_evidence( evidence_json, "Evidence must be a non-empty list", ) eval_json = self._run_quest_judgment(safe_req, filled, "initial") count = u32(0) if sender in self.quest_count_by_owner: count = self.quest_count_by_owner[sender] quest_id = f"quest_{count}" case = QuestCase( quest_id=quest_id, owner_hex=sender.as_hex, requirements=safe_req, evidence_json=normalized_evidence_json, result_json=eval_json, status="evaluated", appeal_count=u32(0), created_at="", ) self.quest_cases[self._quest_case_key(sender, quest_id)] = case self.quest_count_by_owner[sender] = u32(count + 1) pet.last_quest_eval = eval_json self._save_pet(pet) @gl.public.write def appeal_quest(self, quest_id: str, extra_evidence_json: str) -> None: pet = self._require_pet() sender = gl.message.sender_address key = self._quest_case_key(sender, quest_id) if key not in self.quest_cases: raise gl.vm.UserError("Quest case not found") case = self.quest_cases[key] if case.owner_hex != sender.as_hex: raise gl.vm.UserError("Only the quest owner can appeal") if int(case.appeal_count) >= 1: raise gl.vm.UserError("Quest can only be appealed once") try: existing = json.loads(case.evidence_json) except Exception: raise gl.vm.UserError("Stored evidence JSON is invalid") if not isinstance(existing, list): raise gl.vm.UserError("Stored evidence JSON is invalid") extra, _ = self._parse_quest_evidence( extra_evidence_json, "Extra evidence must be a non-empty list", ) combined = existing + extra if len(combined) > MAX_QUEST_EVIDENCE: raise gl.vm.UserError("Maximum 5 evidence items allowed") filled, normalized_evidence_json = self._parse_quest_evidence( json.dumps(combined), "Evidence must be a non-empty list", ) eval_json = self._run_quest_judgment(case.requirements, filled, "appeal") case.evidence_json = normalized_evidence_json case.result_json = eval_json case.status = "appealed" case.appeal_count = u32(int(case.appeal_count) + 1) self.quest_cases[key] = case pet.last_quest_eval = eval_json self._save_pet(pet) # ── view methods ────────────────────────────────────────────────── @gl.public.view def get_pet(self) -> PetState: return self._require_pet() @gl.public.view def has_pet(self) -> bool: return gl.message.sender_address in self.pets @gl.public.view def get_minted_cards(self) -> list: sender = gl.message.sender_address if sender not in self.card_count: return [] count = int(self.card_count[sender]) return [self.cards[f"{sender.as_hex}_{i}"] for i in range(count)] @gl.public.view def get_quest_cases(self) -> list: sender = gl.message.sender_address if sender not in self.quest_count_by_owner: return [] count = int(self.quest_count_by_owner[sender]) cases = [] for i in range(count): quest_id = f"quest_{i}" key = self._quest_case_key(sender, quest_id) if key in self.quest_cases: cases.append(self.quest_cases[key]) return cases @gl.public.view def get_quest_case(self, quest_id: str) -> QuestCase: sender = gl.message.sender_address key = self._quest_case_key(sender, quest_id) if key not in self.quest_cases: raise gl.vm.UserError("Quest case not found") return self.quest_cases[key]