# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from genlayer import * import json import hashlib import typing class Trustdsource(gl.Contract): """ Trustdsource — GenLayer Intelligent Contract Misinformation detection and credibility verification platform. Important: - Storage collections are declared as class fields only. - Do not initialise TreeMap or DynArray inside __init__. - JSON is stored as strings. - No datetime usage, because wall-clock time is unsafe for validator consensus. - Uses GenLayer LLM consensus through gl.vm.run_nondet_unsafe. """ owner: str verification_count: u256 reports: TreeMap[str, str] profiles: TreeMap[str, str] reputation: TreeMap[str, u256] analytics: TreeMap[str, str] verification_index: DynArray[str] def __init__(self) -> None: self.owner = "" self.verification_count = u256(0) # ---------------------------------------------------------- # Internal helpers # ---------------------------------------------------------- def _json_dumps(self, value: typing.Any) -> str: return json.dumps(value, sort_keys=True) def _json_loads(self, value: str) -> typing.Any: try: return json.loads(value) except Exception: return {} def _normalise_score(self, value: typing.Any) -> int: try: score = int(value) except Exception: score = 0 if score < 0: return 0 if score > 100: return 100 return score def _normalise_confidence(self, value: typing.Any) -> str: """ Return confidence as string to avoid float schema/runtime weirdness. Frontend can parse it back to Number. """ try: confidence = float(value) except Exception: confidence = 0.0 if confidence < 0.0: confidence = 0.0 if confidence > 1.0: confidence = 1.0 return str(confidence) def _safe_bool(self, value: typing.Any) -> bool: if value is True: return True if value is False: return False text = str(value).lower() if text == "true": return True return False def _get_report_snapshot(self, report_id: str) -> dict: stored = self.reports.get(report_id, "") if stored == "": return {} loaded = self._json_loads(stored) if isinstance(loaded, dict): return loaded return {} def _store_report_snapshot(self, report_id: str, snapshot: dict) -> None: self.reports[report_id] = self._json_dumps(snapshot) def _fallback_claims(self, claim_summary: str, content: str) -> list: text = claim_summary.strip() if text == "": text = content[:500].strip() if text == "": return [] return [ { "claim_text": text[:700], "claim_type": "factual", "confidence": "0.5", "is_primary": True, } ] def _validate_claims_result(self, leader_result) -> bool: if not isinstance(leader_result, gl.vm.Return): return False data = leader_result.calldata if not isinstance(data, list): return False if len(data) > 12: return False for item in data: if not isinstance(item, dict): return False if not isinstance(item.get("claim_text", ""), str): return False if item.get("claim_text", "") == "": return False return True def _validate_sources_result(self, leader_result) -> bool: if not isinstance(leader_result, gl.vm.Return): return False data = leader_result.calldata if not isinstance(data, list): return False if len(data) > 15: return False for item in data: if not isinstance(item, dict): return False if not isinstance(item.get("title", ""), str): return False score = self._normalise_score(item.get("credibility_score", 0)) if score < 0 or score > 100: return False return True def _validate_analysis_result(self, leader_result) -> bool: if not isinstance(leader_result, gl.vm.Return): return False data = leader_result.calldata if not isinstance(data, dict): return False required_keys = [ "credibility_score", "confidence", "source_quality", "evidence_strength", "consistency_score", "bias_risk", "misinformation_risk", "verdict", "reasoning", "ai_summary", ] for key in required_keys: if key not in data: return False credibility_score = self._normalise_score(data.get("credibility_score", 0)) source_quality = self._normalise_score(data.get("source_quality", 0)) evidence_strength = self._normalise_score(data.get("evidence_strength", 0)) consistency_score = self._normalise_score(data.get("consistency_score", 0)) if credibility_score < 0 or credibility_score > 100: return False if source_quality < 0 or source_quality > 100: return False if evidence_strength < 0 or evidence_strength > 100: return False if consistency_score < 0 or consistency_score > 100: return False verdict = str(data.get("verdict", "")) allowed_verdicts = [ "HIGH_CREDIBILITY", "MODERATE_CREDIBILITY", "LOW_CREDIBILITY", "MISLEADING", "UNVERIFIED", ] if verdict not in allowed_verdicts: return False return True def _llm_claims(self, prompt: str) -> list: def leader_fn(): return gl.nondet.exec_prompt(prompt, response_format="json") result = gl.vm.run_nondet_unsafe( leader_fn, self._validate_claims_result, ) if isinstance(result, list): return result return [] def _llm_sources(self, prompt: str) -> list: def leader_fn(): return gl.nondet.exec_prompt(prompt, response_format="json") result = gl.vm.run_nondet_unsafe( leader_fn, self._validate_sources_result, ) if isinstance(result, list): return result return [] def _llm_analysis(self, prompt: str) -> dict: def leader_fn(): return gl.nondet.exec_prompt(prompt, response_format="json") result = gl.vm.run_nondet_unsafe( leader_fn, self._validate_analysis_result, ) if isinstance(result, dict): return result return {} # ---------------------------------------------------------- # submit_content # ---------------------------------------------------------- @gl.public.write def submit_content( self, title: str, url: str, content: str, claim_summary: str, category: str, submitter_wallet: str, ) -> str: safe_title = title[:200] safe_url = url[:500] safe_content = content[:3000] safe_claim_summary = claim_summary[:1000] safe_category = category[:80] safe_submitter = submitter_wallet[:120] content_hash = hashlib.sha256( (safe_content + safe_url + safe_claim_summary).encode() ).hexdigest() report_id = hashlib.sha256( (content_hash + ":" + str(int(self.verification_count))).encode() ).hexdigest()[:24] snapshot = { "report_id": report_id, "content_hash": content_hash, "title": safe_title, "url": safe_url, "content": safe_content, "claim_summary": safe_claim_summary, "category": safe_category, "submitter_wallet": safe_submitter, "snapshot_timestamp": "seq:" + str(int(self.verification_count)), "status": "snapshot_locked", "locked": True, "claims": [], "sources": [], "verification_analysis": {}, "final_report": {}, "verification_hash": "", } self.reports[report_id] = self._json_dumps(snapshot) self.verification_index.append(report_id) self.verification_count = self.verification_count + u256(1) return report_id # ---------------------------------------------------------- # extract_claims # ---------------------------------------------------------- @gl.public.write def extract_claims(self, report_id: str) -> typing.Any: snapshot = self._get_report_snapshot(report_id) if snapshot == {}: return [] content = str(snapshot.get("content", "")) claim_summary = str(snapshot.get("claim_summary", "")) category = str(snapshot.get("category", "news")) prompt = f""" You are a professional fact-checker and claims analyst. Analyse the following {category} content and extract distinct, verifiable factual claims. CONTENT: {content} CLAIM SUMMARY: {claim_summary} Rules: - Extract only factual claims that can be independently verified. - Focus on statistics, events, attributions, scientific facts, policies, quotes, and factual statements. - Exclude opinions, predictions, vague impressions, and subjective claims. - Return at most 12 claims. - Mark the most important claim as is_primary true. - Confidence must be a number from 0 to 1. Return JSON only, exactly as an array: [ {{ "claim_text": "the exact claim", "claim_type": "statistical|event|attribution|scientific|policy|quote|factual", "confidence": 0.95, "is_primary": true }} ] """ try: claims = self._llm_claims(prompt) except Exception: claims = [] cleaned_claims = [] for item in claims: if isinstance(item, dict): claim_text = str(item.get("claim_text", ""))[:700] if claim_text != "": cleaned_claims.append( { "claim_text": claim_text, "claim_type": str(item.get("claim_type", "factual"))[:40], "confidence": self._normalise_confidence( item.get("confidence", 0.0) ), "is_primary": self._safe_bool(item.get("is_primary", False)), } ) if len(cleaned_claims) == 0: cleaned_claims = self._fallback_claims(claim_summary, content) has_primary = False for claim in cleaned_claims: if claim.get("is_primary", False): has_primary = True if len(cleaned_claims) > 0 and not has_primary: cleaned_claims[0]["is_primary"] = True snapshot["claims"] = cleaned_claims snapshot["status"] = "claims_extracted" self._store_report_snapshot(report_id, snapshot) return cleaned_claims # ---------------------------------------------------------- # discover_sources # ---------------------------------------------------------- @gl.public.write def discover_sources(self, report_id: str) -> typing.Any: snapshot = self._get_report_snapshot(report_id) if snapshot == {}: return [] claims = snapshot.get("claims", []) title = str(snapshot.get("title", "")) url = str(snapshot.get("url", "")) category = str(snapshot.get("category", "news")) content = str(snapshot.get("content", "")) claim_summary = str(snapshot.get("claim_summary", "")) primary_claim = "" if isinstance(claims, list): for claim in claims: if isinstance(claim, dict) and claim.get("is_primary", False): primary_claim = str(claim.get("claim_text", "")) if primary_claim == "" and len(claims) > 0: first_claim = claims[0] if isinstance(first_claim, dict): primary_claim = str(first_claim.get("claim_text", "")) if primary_claim == "": primary_claim = claim_summary[:700] prompt = f""" You are a source credibility analyst. Important: You are not doing open Google search. Analyse only the submitted URL, content excerpt, claim summary, named institutions, named publications, quoted authorities, references, source mentions, and evidence signals present in the provided content. CONTENT TITLE: {title} SUBMITTED URL: {url} CATEGORY: {category} PRIMARY CLAIM: {primary_claim} CLAIM SUMMARY: {claim_summary} CONTENT EXCERPT: {content[:2500]} Task: Classify evidence/source candidates mentioned or implied by the provided content. Rules: - Return at most 15 sources. - If a source is directly named, include it. - If the submitted URL itself is the only source, include it and score it honestly. - If evidence is weak or unclear, use lower credibility and relevance. - credibility_score must be 0 to 100. - relevance_score must be 0 to 1. - is_supporting should be true if the source appears to support the claim, false if it conflicts. Return JSON only, exactly as an array: [ {{ "url": "full url if known, otherwise empty string", "title": "source or evidence title", "domain": "domain.com or institution name", "publication": "Publication Name", "credibility_score": 85, "source_type": "news|government|academic|primary_source|blog|social|other", "is_supporting": true, "relevance_score": 0.92, "snippet": "short relevant evidence excerpt" }} ] """ try: sources = self._llm_sources(prompt) except Exception: sources = [] cleaned_sources = [] for item in sources: if isinstance(item, dict): cleaned_sources.append( { "url": str(item.get("url", ""))[:500], "title": str(item.get("title", ""))[:250], "domain": str(item.get("domain", ""))[:120], "publication": str(item.get("publication", ""))[:120], "credibility_score": self._normalise_score( item.get("credibility_score", 0) ), "source_type": str(item.get("source_type", "other"))[:40], "is_supporting": self._safe_bool( item.get("is_supporting", True) ), "relevance_score": self._normalise_confidence( item.get("relevance_score", 0.0) ), "snippet": str(item.get("snippet", ""))[:700], } ) if len(cleaned_sources) == 0 and url != "": cleaned_sources.append( { "url": url, "title": title, "domain": url[:120], "publication": "Submitted URL", "credibility_score": 40, "source_type": "other", "is_supporting": True, "relevance_score": "0.5", "snippet": content[:500], } ) snapshot["sources"] = cleaned_sources snapshot["status"] = "sources_discovered" self._store_report_snapshot(report_id, snapshot) return cleaned_sources # ---------------------------------------------------------- # verify_claims # ---------------------------------------------------------- @gl.public.write def verify_claims(self, report_id: str) -> typing.Any: snapshot = self._get_report_snapshot(report_id) if snapshot == {}: return {"error": "report_not_found"} claims = snapshot.get("claims", []) sources = snapshot.get("sources", []) content = str(snapshot.get("content", "")) category = str(snapshot.get("category", "news")) title = str(snapshot.get("title", "")) supporting = [] conflicting = [] if isinstance(sources, list): for source in sources: if isinstance(source, dict): if source.get("is_supporting", True): supporting.append(source) else: conflicting.append(source) claims_text = "" if isinstance(claims, list): for claim in claims[:10]: if isinstance(claim, dict): claims_text = claims_text + "- " + str(claim.get("claim_text", "")) + "\n" supporting_text = "" for source in supporting[:8]: supporting_text = ( supporting_text + "- [" + str(source.get("credibility_score", 0)) + "] " + str(source.get("title", "")) + " (" + str(source.get("domain", "")) + "): " + str(source.get("snippet", "")) + "\n" ) conflicting_text = "" for source in conflicting[:5]: conflicting_text = ( conflicting_text + "- [" + str(source.get("credibility_score", 0)) + "] " + str(source.get("title", "")) + " (" + str(source.get("domain", "")) + "): " + str(source.get("snippet", "")) + "\n" ) prompt = f""" You are a professional misinformation analyst and fact-checker. CONTENT TITLE: {title} CONTENT CATEGORY: {category} EXTRACTED CLAIMS: {claims_text if claims_text != "" else "No specific claims extracted"} SUPPORTING EVIDENCE: {supporting_text if supporting_text != "" else "No supporting evidence found"} CONFLICTING EVIDENCE: {conflicting_text if conflicting_text != "" else "No conflicting evidence found"} ORIGINAL CONTENT EXCERPT: {content[:1500]} Analyse: 1. Whether the claims are supported by credible evidence. 2. Whether the sources agree or contradict each other. 3. Whether the content accurately represents the evidence. 4. Whether there are misinformation signals such as sensationalism, false attribution, cherry-picked data, misleading framing, or outdated information presented as current. 5. Whether there are bias signals such as political, commercial, or confirmation bias. Return JSON only, exactly as an object: {{ "credibility_score": 0, "confidence": 0.0, "source_quality": 0, "evidence_strength": 0, "consistency_score": 0, "bias_risk": "LOW", "misinformation_risk": "LOW", "verdict": "UNVERIFIED", "reasoning": "detailed explanation", "ai_summary": "1-2 sentence plain English summary", "misinformation_signals": [], "bias_signals": [] }} Allowed verdicts: HIGH_CREDIBILITY, MODERATE_CREDIBILITY, LOW_CREDIBILITY, MISLEADING, UNVERIFIED Allowed bias_risk: LOW, MEDIUM, HIGH Allowed misinformation_risk: LOW, MEDIUM, HIGH, CRITICAL Scoring: - HIGH_CREDIBILITY: 80-100 - MODERATE_CREDIBILITY: 55-79 - LOW_CREDIBILITY: 30-54 - MISLEADING: 0-39 with strong misinformation signals - UNVERIFIED: insufficient evidence """ try: analysis = self._llm_analysis(prompt) except Exception: analysis = {} if analysis == {}: analysis = { "credibility_score": 0, "confidence": 0.0, "source_quality": 0, "evidence_strength": 0, "consistency_score": 0, "bias_risk": "LOW", "misinformation_risk": "LOW", "verdict": "UNVERIFIED", "reasoning": "Unable to complete analysis from available evidence.", "ai_summary": "Verification could not be completed.", "misinformation_signals": [], "bias_signals": [], } cleaned_analysis = { "credibility_score": self._normalise_score( analysis.get("credibility_score", 0) ), "confidence": self._normalise_confidence(analysis.get("confidence", 0.0)), "source_quality": self._normalise_score(analysis.get("source_quality", 0)), "evidence_strength": self._normalise_score( analysis.get("evidence_strength", 0) ), "consistency_score": self._normalise_score( analysis.get("consistency_score", 0) ), "bias_risk": str(analysis.get("bias_risk", "LOW"))[:20], "misinformation_risk": str(analysis.get("misinformation_risk", "LOW"))[:20], "verdict": str(analysis.get("verdict", "UNVERIFIED"))[:40], "reasoning": str(analysis.get("reasoning", ""))[:2000], "ai_summary": str(analysis.get("ai_summary", ""))[:500], "misinformation_signals": analysis.get("misinformation_signals", []), "bias_signals": analysis.get("bias_signals", []), } snapshot["verification_analysis"] = cleaned_analysis snapshot["status"] = "claims_verified" self._store_report_snapshot(report_id, snapshot) return cleaned_analysis # ---------------------------------------------------------- # calculate_credibility # ---------------------------------------------------------- @gl.public.write def calculate_credibility(self, report_id: str) -> typing.Any: snapshot = self._get_report_snapshot(report_id) if snapshot == {}: return {"error": "report_not_found"} analysis = snapshot.get("verification_analysis", {}) sources = snapshot.get("sources", []) claims = snapshot.get("claims", []) raw_cred = self._normalise_score(analysis.get("credibility_score", 0)) raw_sq = self._normalise_score(analysis.get("source_quality", 0)) raw_es = self._normalise_score(analysis.get("evidence_strength", 0)) raw_cs = self._normalise_score(analysis.get("consistency_score", 0)) source_count = 0 claim_count = 0 if isinstance(sources, list): source_count = len(sources) if isinstance(claims, list): claim_count = len(claims) source_count_bonus = min(source_count * 2, 10) claim_coverage = min(claim_count, 5) credibility_score = int( raw_cred * 0.40 + raw_sq * 0.25 + raw_es * 0.20 + raw_cs * 0.15 + source_count_bonus + claim_coverage ) if credibility_score > 100: credibility_score = 100 misinformation_risk = str(analysis.get("misinformation_risk", "LOW")) if credibility_score >= 80: verdict = "HIGH_CREDIBILITY" elif credibility_score >= 55: verdict = "MODERATE_CREDIBILITY" elif credibility_score >= 30: verdict = "LOW_CREDIBILITY" elif credibility_score > 0 and misinformation_risk in ["HIGH", "CRITICAL"]: verdict = "MISLEADING" else: verdict = "UNVERIFIED" supporting_sources = [] conflicting_sources = [] if isinstance(sources, list): for source in sources: if isinstance(source, dict): if source.get("is_supporting", True): if len(supporting_sources) < 10: supporting_sources.append(source) else: if len(conflicting_sources) < 5: conflicting_sources.append(source) final_report = { "report_id": report_id, "content_hash": snapshot.get("content_hash", ""), "credibility_score": credibility_score, "confidence": analysis.get("confidence", "0.0"), "source_quality": raw_sq, "evidence_strength": raw_es, "consistency_score": raw_cs, "bias_risk": analysis.get("bias_risk", "LOW"), "misinformation_risk": misinformation_risk, "verdict": verdict, "supporting_sources": supporting_sources, "conflicting_sources": conflicting_sources, "reasoning": analysis.get("reasoning", ""), "ai_summary": analysis.get("ai_summary", ""), "misinformation_signals": analysis.get("misinformation_signals", []), "bias_signals": analysis.get("bias_signals", []), "claims": claims, "created_at": "seq:" + str(int(self.verification_count)), } snapshot["final_report"] = final_report snapshot["status"] = "complete" self._store_report_snapshot(report_id, snapshot) return final_report # ---------------------------------------------------------- # store_report # ---------------------------------------------------------- @gl.public.write def store_report(self, report_id: str) -> bool: snapshot = self._get_report_snapshot(report_id) if snapshot == {}: return False if snapshot.get("status", "") != "complete": return False report = snapshot.get("final_report", {}) verification_hash = hashlib.sha256( self._json_dumps(report).encode() ).hexdigest() snapshot["verification_hash"] = verification_hash snapshot["stored_at"] = "seq:" + str(int(self.verification_count)) self._store_report_snapshot(report_id, snapshot) analytics_key = "all_time" stored_analytics = self.analytics.get(analytics_key, "") if stored_analytics == "": analytics = { "date": analytics_key, "total": 0, "high_credibility": 0, "moderate_credibility": 0, "low_credibility": 0, "misleading": 0, "unverified": 0, "total_score": 0, } else: loaded = self._json_loads(stored_analytics) if isinstance(loaded, dict): analytics = loaded else: analytics = { "date": analytics_key, "total": 0, "high_credibility": 0, "moderate_credibility": 0, "low_credibility": 0, "misleading": 0, "unverified": 0, "total_score": 0, } verdict = str(report.get("verdict", "UNVERIFIED")).lower() analytics["total"] = int(analytics.get("total", 0)) + 1 analytics["total_score"] = int(analytics.get("total_score", 0)) + int( report.get("credibility_score", 0) ) if verdict == "high_credibility": analytics["high_credibility"] = int( analytics.get("high_credibility", 0) ) + 1 elif verdict == "moderate_credibility": analytics["moderate_credibility"] = int( analytics.get("moderate_credibility", 0) ) + 1 elif verdict == "low_credibility": analytics["low_credibility"] = int( analytics.get("low_credibility", 0) ) + 1 elif verdict == "misleading": analytics["misleading"] = int(analytics.get("misleading", 0)) + 1 else: analytics["unverified"] = int(analytics.get("unverified", 0)) + 1 self.analytics[analytics_key] = self._json_dumps(analytics) return True # ---------------------------------------------------------- # update_reputation # ---------------------------------------------------------- @gl.public.write def update_reputation(self, wallet_address: str, report_id: str) -> u256: current_score = self.reputation.get(wallet_address, u256(0)) snapshot = self._get_report_snapshot(report_id) if snapshot == {}: return current_score report = snapshot.get("final_report", {}) credibility_score = int(report.get("credibility_score", 0)) delta = 5 if credibility_score >= 80: delta = 15 elif credibility_score >= 55: delta = 10 elif credibility_score >= 30: delta = 7 new_score_int = int(current_score) + delta new_score = u256(new_score_int) self.reputation[wallet_address] = new_score stored_profile = self.profiles.get(wallet_address, "") if stored_profile == "": profile = { "wallet": wallet_address, "verifications": 0, "reputation_score": 0, "last_verification": "", } else: loaded_profile = self._json_loads(stored_profile) if isinstance(loaded_profile, dict): profile = loaded_profile else: profile = { "wallet": wallet_address, "verifications": 0, "reputation_score": 0, "last_verification": "", } profile["wallet"] = wallet_address profile["verifications"] = int(profile.get("verifications", 0)) + 1 profile["reputation_score"] = new_score_int profile["last_verification"] = report_id self.profiles[wallet_address] = self._json_dumps(profile) return new_score # ---------------------------------------------------------- # run_full_verification # ---------------------------------------------------------- @gl.public.write def run_full_verification( self, title: str, url: str, content: str, claim_summary: str, category: str, submitter_wallet: str, ) -> typing.Any: report_id = self.submit_content( title, url, content, claim_summary, category, submitter_wallet, ) self.extract_claims(report_id) self.discover_sources(report_id) self.verify_claims(report_id) final_report = self.calculate_credibility(report_id) self.store_report(report_id) self.update_reputation(submitter_wallet, report_id) return final_report # ---------------------------------------------------------- # Views # ---------------------------------------------------------- @gl.public.view def get_report(self, report_id: str) -> typing.Any: snapshot = self._get_report_snapshot(report_id) if snapshot == {}: return {} final_report = snapshot.get("final_report", {}) return { "report_id": report_id, "content_hash": snapshot.get("content_hash", ""), "verification_hash": snapshot.get("verification_hash", ""), "snapshot_timestamp": snapshot.get("snapshot_timestamp", ""), "status": snapshot.get("status", ""), "title": snapshot.get("title", ""), "url": snapshot.get("url", ""), "category": snapshot.get("category", ""), "submitter_wallet": snapshot.get("submitter_wallet", ""), "credibility_score": final_report.get("credibility_score", 0), "confidence": final_report.get("confidence", "0.0"), "source_quality": final_report.get("source_quality", 0), "evidence_strength": final_report.get("evidence_strength", 0), "consistency_score": final_report.get("consistency_score", 0), "bias_risk": final_report.get("bias_risk", ""), "misinformation_risk": final_report.get("misinformation_risk", ""), "verdict": final_report.get("verdict", "UNVERIFIED"), "supporting_sources": final_report.get("supporting_sources", []), "conflicting_sources": final_report.get("conflicting_sources", []), "reasoning": final_report.get("reasoning", ""), "ai_summary": final_report.get("ai_summary", ""), "misinformation_signals": final_report.get("misinformation_signals", []), "bias_signals": final_report.get("bias_signals", []), "claims": final_report.get("claims", snapshot.get("claims", [])), "created_at": final_report.get("created_at", ""), } @gl.public.view def get_snapshot(self, report_id: str) -> typing.Any: snapshot = self._get_report_snapshot(report_id) return snapshot @gl.public.view def get_profile(self, wallet_address: str) -> typing.Any: reputation_score = int(self.reputation.get(wallet_address, u256(0))) if reputation_score >= 1000: tier = "verification_expert" elif reputation_score >= 500: tier = "trusted_researcher" elif reputation_score >= 200: tier = "researcher" elif reputation_score >= 50: tier = "analyst" else: tier = "new" stored_profile = self.profiles.get(wallet_address, "") if stored_profile == "": profile = { "wallet": wallet_address, "verifications": 0, "reputation_score": reputation_score, "last_verification": "", } else: loaded_profile = self._json_loads(stored_profile) if isinstance(loaded_profile, dict): profile = loaded_profile else: profile = { "wallet": wallet_address, "verifications": 0, "reputation_score": reputation_score, "last_verification": "", } return { "wallet_address": wallet_address, "reputation_score": reputation_score, "reputation_tier": tier, "total_verifications": profile.get("verifications", 0), "last_verification": profile.get("last_verification", ""), } @gl.public.view def get_analytics(self, analytics_key: str) -> typing.Any: stored_analytics = self.analytics.get(analytics_key, "") if stored_analytics == "": return { "date": analytics_key, "total": 0, "high_credibility": 0, "moderate_credibility": 0, "low_credibility": 0, "misleading": 0, "unverified": 0, "total_score": 0, "avg_score": 0, } loaded = self._json_loads(stored_analytics) if not isinstance(loaded, dict): return { "date": analytics_key, "total": 0, "high_credibility": 0, "moderate_credibility": 0, "low_credibility": 0, "misleading": 0, "unverified": 0, "total_score": 0, "avg_score": 0, } total = int(loaded.get("total", 0)) total_score = int(loaded.get("total_score", 0)) avg_score = 0 if total > 0: avg_score = total_score // total loaded["avg_score"] = avg_score return loaded @gl.public.view def get_total_verifications(self) -> u256: return self.verification_count @gl.public.view def get_report_id_at(self, index: u256) -> str: idx = int(index) total = len(self.verification_index) if idx >= total: return "" return self.verification_index[idx] @gl.public.view def get_recent_report_ids(self, limit: u256) -> typing.Any: total = len(self.verification_index) lim = int(limit) if lim <= 0: return [] if lim > 25: lim = 25 start = total - lim if start < 0: start = 0 result = [] i = start while i < total: result.append(self.verification_index[i]) i = i + 1 return result