# { "Depends": "py-genlayer:test" } import json from dataclasses import dataclass from genlayer import * ERROR_EXPECTED = "[EXPECTED]" ERROR_LLM = "[LLM_ERROR]" SCORE_TOLERANCE = 15 @allow_storage @dataclass class FactCheck: check_id: u256 submitter: Address claim_text: str source_url: str truth_score: u256 verdict: str evidence_json: str sources_checked: u256 def _verdict_for_score(score: int) -> str: if score >= 90: return "VERIFIED TRUE" if score >= 70: return "MOSTLY TRUE" if score >= 50: return "MIXED" if score >= 30: return "MOSTLY FALSE" if score >= 10: return "FALSE" return "COMPLETELY FALSE" def _clamp_score(raw) -> int: try: value = int(round(float(str(raw).strip()))) except (ValueError, TypeError): return 50 if value < 0: return 0 if value > 100: return 100 return value def _fact_check_prompt(claim_text: str, source_url: str) -> str: return f"""You are TruthLens, an AI crypto news fact-checker. Analyze this claim for accuracy using your knowledge of crypto, blockchain, DeFi, and Web3. Claim: \"\"\"{claim_text}\"\"\" Source URL: {source_url} Cross-reference this claim against: 1. Known blockchain facts (protocol specs, tokenomics, governance) 2. Historical crypto events and timelines 3. Technical accuracy of any code/protocol claims 4. Market data consistency 5. Community consensus and expert opinions Return ONLY valid JSON: {{ "truth_score": <0-100 integer>, "evidence": [ {{"source": "", "supports": true, "detail": ""}}, {{"source": "", "supports": false, "detail": ""}} ], "key_findings": "<2-3 sentence summary>", "red_flags": ["", ""], "sources_checked": }} Scores: 90-100=Verified True, 70-89=Mostly True, 50-69=Mixed, 30-49=Mostly False, 10-29=False, 0-9=Completely False """ class TruthLens(gl.Contract): owner: Address check_count: u256 checks: TreeMap[u256, FactCheck] check_ids: DynArray[u256] def __init__(self): self.owner = gl.message.sender_address self.check_count = u256(0) def _analyze_claim(self, claim_text: str, source_url: str) -> dict: prompt = _fact_check_prompt(claim_text, source_url) def leader_fn(): result = gl.nondet.exec_prompt(prompt, response_format="json") if not isinstance(result, dict): raise gl.vm.UserError(f"{ERROR_LLM} Invalid response format") result["truth_score"] = _clamp_score(result.get("truth_score", 50)) result["verdict"] = _verdict_for_score(result["truth_score"]) return result def validator_fn(leaders_res): if not isinstance(leaders_res, gl.vm.Return): return False v = leader_fn() leader_score = _clamp_score(leaders_res.calldata.get("truth_score", 50)) validator_score = _clamp_score(v.get("truth_score", 50)) if abs(leader_score - validator_score) > SCORE_TOLERANCE: return False return _verdict_for_score(leader_score) == _verdict_for_score(validator_score) return gl.vm.run_nondet_unsafe(leader_fn, validator_fn) @gl.public.write def submit_claim(self, claim_text: str, source_url: str) -> u256: cleaned = claim_text.strip() if len(cleaned) < 20: raise gl.vm.UserError(f"{ERROR_EXPECTED} Claim must be at least 20 characters") if len(cleaned) > 2000: raise gl.vm.UserError(f"{ERROR_EXPECTED} Claim must be 2000 characters or less") analysis = self._analyze_claim(cleaned, source_url.strip()) check_id = self.check_count evidence_json = json.dumps(analysis.get("evidence", []), sort_keys=True) truth_score = int(analysis["truth_score"]) verdict = str(analysis["verdict"]) sources_checked = int(analysis.get("sources_checked", 0)) self.checks[check_id] = FactCheck( check_id=check_id, submitter=gl.message.sender_address, claim_text=cleaned, source_url=source_url.strip(), truth_score=truth_score, verdict=verdict, evidence_json=evidence_json, sources_checked=sources_checked, ) self.check_ids.append(check_id) self.check_count = check_id + 1 return check_id @gl.public.view def get_check(self, check_id: u256) -> dict: if check_id not in self.checks: raise gl.vm.UserError(f"{ERROR_EXPECTED} Check not found") fc = self.checks[check_id] return { "check_id": fc.check_id, "submitter": fc.submitter.as_hex, "claim_text": fc.claim_text, "source_url": fc.source_url, "truth_score": fc.truth_score, "verdict": fc.verdict, "evidence": json.loads(fc.evidence_json), "sources_checked": fc.sources_checked, } @gl.public.view def get_all_checks(self) -> list: results = [] count = int(self.check_count) i = count - 1 while i >= 0 and len(results) < 50: fc = self.checks[i] preview = fc.claim_text if len(preview) > 120: preview = preview[:120] + "..." results.append({ "check_id": fc.check_id, "submitter": fc.submitter.as_hex, "claim_preview": preview, "truth_score": fc.truth_score, "verdict": fc.verdict, }) i -= 1 return results @gl.public.view def get_leaderboard(self) -> list: submitter_stats = {} count = int(self.check_count) for i in range(count): fc = self.checks[i] addr = fc.submitter.as_hex if addr not in submitter_stats: submitter_stats[addr] = {"address": addr, "total_checks": 0, "avg_accuracy": 0, "total_score": 0} submitter_stats[addr]["total_checks"] += 1 submitter_stats[addr]["total_score"] += int(fc.truth_score) leaderboard = [] for addr, stats in submitter_stats.items(): if stats["total_checks"] > 0: stats["avg_accuracy"] = int(stats["total_score"] / stats["total_checks"]) del stats["total_score"] leaderboard.append(stats) leaderboard.sort(key=lambda x: x["total_checks"], reverse=True) return leaderboard[:20]