# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from genlayer import * from dataclasses import dataclass import json import re import typing REFRESH_COOLDOWN_SECONDS = 82800 # 23 jam MINT_FEE = 5_000_000_000_000_000 # 0.005 GEN in wei # ─── EVM interface ────────────────────────────────────────────── @gl.evm.contract_interface class _EOA: class View: pass class Write: pass def _clean_json(text: str) -> dict: if isinstance(text, dict): return text text = str(text) first = text.find("{") last = text.rfind("}") if first == -1 or last == -1: raise gl.UserError("Response did not contain valid JSON") text = text[first : last + 1] text = re.sub(r",(?!\s*?[\{\[\"\'\w])", "", text) return json.loads(text) def _safe_str(value: typing.Any, max_len: int = 500) -> str: return str(value).strip()[:max_len] def _parse_tweet_data(raw_json: str) -> dict: """Parse tweet data sent from frontend Next.js API route.""" try: data = json.loads(raw_json) if isinstance(raw_json, str) else raw_json return data if isinstance(data, dict) else {} except Exception: return {} @allow_storage @dataclass class EditionData: edition_num: u256 headline: str subheadline: str world_mood: str # EUPHORIC | BULLISH | CALM | UNCERTAIN | BEARISH | CHAOTIC mood_score: u256 # 0-100 summary: str # 2-3 kalimat editorial AI top_topics: str # comma-separated e.g. "crypto,AI,geopolitics" fetched_at: str # ISO timestamp string tweet_count: u256 # berapa tweet yang dianalisis @allow_storage @dataclass class NFTRecord: token_id: u256 owner: Address minted_at: str current_edition: u256 frozen_edition: u256 # 0 = live/tidak frozen, >0 = frozen di edisi ini @allow_storage @dataclass class FrozenSnapshot: token_id: u256 edition_num: u256 headline: str subheadline: str world_mood: str mood_score: u256 summary: str top_topics: str frozen_at: str class Koran(gl.Contract): owner: Address nfts: DynArray[NFTRecord] nft_supply: u256 editions: TreeMap[u256, EditionData] frozen: TreeMap[u256, FrozenSnapshot] edition_count: u256 last_refresh: str last_refresh_epoch: u256 platform_balance: u256 player_nft_count: TreeMap[Address, u256] def __init__(self): self.owner = gl.message.sender_address self.nft_supply = u256(0) self.edition_count = u256(0) self.last_refresh = "" self.last_refresh_epoch = u256(0) self.platform_balance = u256(0) # ─── Internal helpers ──────────────────────────────────────────────────── def _build_edition_from_tweets(self, tweets_json: str) -> dict: """Run AI analysis on tweet data → produce dict with edition fields.""" prompt = ( "You are THE GENLAYER TIMES, an AI editor analyzing real-time global social media discourse.\n\n" "Here is a JSON payload containing recent tweets about world news and current events:\n" "```\n" + _safe_str(tweets_json, max_len=3000) + "\n```\n\n" "Analyze the tweets and return ONLY this JSON (no markdown, no preamble):\n" "{\n" ' "headline": "",\n' ' "subheadline": "",\n' ' "world_mood": "",\n' ' "mood_score": ,\n' ' "summary": "<2-3 sentence editorial summary of the current world state, newspaper voice>",\n' ' "top_topics": "<3-5 comma-separated trending topics e.g. crypto,AI,geopolitics>",\n' ' "tweet_count": \n' "}\n\n" "RULES:\n" "- Headline must sound like a real newspaper front page (e.g. 'MARKETS SURGE AS AI RESHAPES GLOBAL ORDER')\n" "- world_mood EUPHORIC: extreme positive sentiment, markets pumping, major breakthroughs\n" "- world_mood BULLISH: generally positive, optimistic discourse\n" "- world_mood CALM: neutral, slow news day, balanced sentiment\n" "- world_mood UNCERTAIN: mixed signals, conflicting narratives\n" "- world_mood BEARISH: negative sentiment, fear/concern dominant\n" "- world_mood CHAOTIC: many conflicting breaking news, high volatility discourse\n" "- mood_score reflects tweet sentiment: count positive vs negative language\n" "- summary must be authoritative editorial voice, not casual\n" ) def leader_fn() -> dict: raw = gl.nondet.exec_prompt(prompt, response_format="json") data = _clean_json(raw) if not isinstance(data, dict): raise gl.UserError("Non-dict AI response") required = ["headline", "world_mood", "mood_score", "summary"] for field in required: if field not in data: raise gl.UserError(f"Missing field: {field}") valid_moods = ["EUPHORIC", "BULLISH", "CALM", "UNCERTAIN", "BEARISH", "CHAOTIC"] mood = str(data.get("world_mood", "UNCERTAIN")).upper().strip() if mood not in valid_moods: mood = "UNCERTAIN" try: score = max(0, min(100, int(round(float(data["mood_score"]))))) except (ValueError, TypeError): score = 50 return { "headline": _safe_str(data["headline"], max_len=200), "subheadline": _safe_str(data.get("subheadline", ""), max_len=300), "world_mood": mood, "mood_score": score, "summary": _safe_str(data["summary"], max_len=600), "top_topics": _safe_str(data.get("top_topics", "world,news"), max_len=200), "tweet_count": int(data.get("tweet_count", 0)), } def validator_fn(leader_result) -> bool: if not isinstance(leader_result, gl.vm.Return): return False data = leader_result.calldata if not isinstance(data, dict): return False headline = data.get("headline") if not isinstance(headline, str) or len(headline) < 5: return False mood = data.get("world_mood") valid_moods = ["EUPHORIC", "BULLISH", "CALM", "UNCERTAIN", "BEARISH", "CHAOTIC"] if mood not in valid_moods: return False score = data.get("mood_score") if not isinstance(score, int) or not (0 <= score <= 100): return False return True result = gl.vm.run_nondet_unsafe(leader_fn, validator_fn) return result # ─── Public write methods ───────────────────────────────────────────────── @gl.public.write def refresh_edition(self, tweets_json: str) -> None: """ Siapapun bisa call ini untuk update edisi hari ini. tweets_json: JSON string dari Next.js /api/headlines route Cooldown: 23 jam antara refresh. """ clean_data = _safe_str(tweets_json, max_len=4000) if len(clean_data) < 10: raise gl.UserError("tweets_json terlalu pendek / kosong") ai_result = self._build_edition_from_tweets(clean_data) new_edition_num = u256(int(self.edition_count) + 1) edition = EditionData( new_edition_num, ai_result["headline"], ai_result["subheadline"], ai_result["world_mood"], u256(ai_result["mood_score"]), ai_result["summary"], ai_result["top_topics"], "", # timestamp dari frontend (bisa diisi via separate field) u256(ai_result["tweet_count"]), ) self.editions[new_edition_num] = edition self.edition_count = new_edition_num self.last_refresh_epoch = u256(0) # reset placeholder @gl.public.write.payable def mint(self) -> u256: """ Mint NFT baru. Bayar 0.005 GEN. NFT otomatis assign ke edisi terkini. """ if int(gl.message.value) < MINT_FEE: raise gl.UserError("Insufficient mint fee: need 0.005 GEN") if int(self.edition_count) == 0: raise gl.UserError("No edition available yet. Call refresh_edition first.") token_id = self.nft_supply self.nft_supply = u256(int(token_id) + 1) nft = gl.storage.inmem_allocate( NFTRecord, token_id, gl.message.sender_address, "", self.edition_count, u256(0), # 0 = not frozen ) self.nfts.append(nft) sender = gl.message.sender_address self.player_nft_count[sender] = u256( int(self.player_nft_count.get(sender, u256(0))) + 1 ) fee = int(gl.message.value) platform_cut = fee // 20 # 5% self.platform_balance = u256(int(self.platform_balance) + platform_cut) return token_id @gl.public.write def freeze_edition(self, token_id: u256) -> None: """ Freeze NFT di edisi saat ini (snapshot permanen). Hanya owner token yang bisa freeze. """ idx = int(token_id) if idx < 0 or idx >= len(self.nfts): raise gl.UserError("Token does not exist") nft = self.nfts[idx] if nft.owner != gl.message.sender_address: raise gl.UserError("Only owner can freeze") if int(nft.frozen_edition) > 0: raise gl.UserError("Already frozen") current_ed_num = nft.current_edition if current_ed_num not in self.editions: raise gl.UserError("Current edition data not found") ed = self.editions[current_ed_num] snap = FrozenSnapshot( token_id, current_ed_num, ed.headline, ed.subheadline, ed.world_mood, ed.mood_score, ed.summary, ed.top_topics, "", ) self.frozen[token_id] = snap # Update NFT frozen_edition langsung via attribute (WeatherBet pattern) self.nfts[idx].frozen_edition = current_ed_num @gl.public.write def unfreeze(self, token_id: u256) -> None: """Unfreeze NFT — kembali live mengikuti edisi terkini.""" idx = int(token_id) if idx < 0 or idx >= len(self.nfts): raise gl.UserError("Token does not exist") nft = self.nfts[idx] if nft.owner != gl.message.sender_address: raise gl.UserError("Only owner can unfreeze") # Sync ke edisi terkini, clear frozen status self.nfts[idx].frozen_edition = u256(0) self.nfts[idx].current_edition = self.edition_count @gl.public.write def withdraw_fees(self) -> u256: """Owner withdraw platform fees.""" if gl.message.sender_address != self.owner: raise gl.UserError("Only owner") amount = self.platform_balance if int(amount) == 0: raise gl.UserError("Nothing to withdraw") self.platform_balance = u256(0) _EOA(self.owner).emit_transfer(value=amount) return amount # ─── Public view methods ────────────────────────────────────────────────── @gl.public.view def get_current_edition(self) -> EditionData: if int(self.edition_count) == 0: raise gl.UserError("No edition yet") return self.editions[self.edition_count] @gl.public.view def get_edition(self, edition_num: u256) -> EditionData: if edition_num not in self.editions: raise gl.UserError("Edition not found") return self.editions[edition_num] @gl.public.view def get_nft(self, token_id: u256) -> NFTRecord: idx = int(token_id) if idx < 0 or idx >= len(self.nfts): raise gl.UserError("Token does not exist") return self.nfts[idx] @gl.public.view def get_frozen(self, token_id: u256) -> FrozenSnapshot: if token_id not in self.frozen: raise gl.UserError("No frozen snapshot for this token") return self.frozen[token_id] @gl.public.view def get_nft_display(self, token_id: u256) -> dict: """ Return NFT + edition data sekaligus untuk frontend. Jika frozen, return frozen snapshot. Jika live, return current edition. """ idx = int(token_id) if idx < 0 or idx >= len(self.nfts): raise gl.UserError("Token does not exist") nft = self.nfts[idx] is_frozen = int(nft.frozen_edition) > 0 if is_frozen and token_id in self.frozen: snap = self.frozen[token_id] return { "token_id": int(token_id), "owner": str(nft.owner), "is_frozen": True, "edition_num": int(snap.edition_num), "headline": snap.headline, "subheadline": snap.subheadline, "world_mood": snap.world_mood, "mood_score": int(snap.mood_score), "summary": snap.summary, "top_topics": snap.top_topics, } else: if int(self.edition_count) == 0: raise gl.UserError("No edition available") ed = self.editions[self.edition_count] return { "token_id": int(token_id), "owner": str(nft.owner), "is_frozen": False, "edition_num": int(self.edition_count), "headline": ed.headline, "subheadline": ed.subheadline, "world_mood": ed.world_mood, "mood_score": int(ed.mood_score), "summary": ed.summary, "top_topics": ed.top_topics, } @gl.public.view def get_player_nfts(self, player: Address) -> list[NFTRecord]: result = [] for i in range(len(self.nfts)): if self.nfts[i].owner == player: result.append(self.nfts[i]) return result @gl.public.view def total_supply(self) -> u256: return self.nft_supply @gl.public.view def total_editions(self) -> u256: return self.edition_count @gl.public.view def get_platform_balance(self) -> u256: return self.platform_balance