# v0.2.16 # { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from genlayer import * import json from dataclasses import dataclass from datetime import datetime, timezone @allow_storage @dataclass class GrantRound: round_id: str creator: Address title: str description: str judging_criteria: str created_at: u64 is_active: bool proposal_deadline: u64 review_deadline: u64 max_winners: u32 @allow_storage @dataclass class Proposal: proposal_id: str round_id: str submitter: Address title: str summary: str proposal_url: str submitted_at: u64 status: str # SUBMITTED|JUDGED|REJECTED|APPROVED|APPEALED|ESCALATED|ERROR|AWARDED ai_verdict: str # APPROVED|REJECTED|ESCALATED|UNDETERMINED ai_score: u32 # 0-100 ai_reason_code: str ai_reason: str ai_confidence_band: str # LOW|MEDIUM|HIGH appeal_tx_id: str appealed: bool appeal_status: str # PENDING|APPROVED|REJECTED|ESCALATED|NONE appeal_verdict: str appeal_reason_code: str appeal_reason: str appeal_confidence_band: str final_status: str # FINAL|PENDING reviewed_at: u64 class GrantPlatform(gl.Contract): owner: Address grant_rounds: TreeMap[str, GrantRound] proposals: TreeMap[str, Proposal] round_count: u256 proposal_count: u256 proposal_ids_by_round: TreeMap[str, DynArray[str]] proposal_ids_by_submitter: TreeMap[Address, DynArray[str]] seen_round_ids: TreeMap[str, u64] seen_proposal_ids: TreeMap[str, u64] paused: bool def __init__(self): self.owner = gl.message.sender_address self.round_count = u256(0) self.proposal_count = u256(0) self.paused = False @gl.public.view def get_owner(self) -> str: return self.owner.as_hex @gl.public.view def is_paused(self) -> bool: return self.paused @gl.public.write def pause(self): if gl.message.sender_address != self.owner: raise gl.vm.UserError("Only owner can pause") self.paused = True @gl.public.write def unpause(self): if gl.message.sender_address != self.owner: raise gl.vm.UserError("Only owner can unpause") self.paused = False @gl.public.write def create_grant_round(self, round_id: str, title: str, description: str, judging_criteria: str, proposal_deadline: int, review_deadline: int, max_winners: int): if self.paused: raise gl.vm.UserError("Paused") if not (1 <= len(round_id) <= 64): raise gl.vm.UserError("Invalid round_id") if self.seen_round_ids.get(round_id, 0) != 0: raise gl.vm.UserError("Duplicate round id") if proposal_deadline >= review_deadline: raise gl.vm.UserError("Proposal deadline must be before review deadline") if max_winners < 1: raise gl.vm.UserError("max_winners must be at least 1") now = int(datetime.now(timezone.utc).timestamp()) r = GrantRound( round_id=round_id, creator=gl.message.sender_address, title=title, description=description, judging_criteria=judging_criteria, created_at=now, is_active=True, proposal_deadline=u64(proposal_deadline), review_deadline=u64(review_deadline), max_winners=u32(max_winners) ) self.grant_rounds[round_id] = r self.seen_round_ids[round_id] = u64(now) self.round_count += u256(1) @gl.public.write def close_grant_round(self, round_id: str): if self.paused: raise gl.vm.UserError("Paused") gr = self.grant_rounds.get(round_id, None) if gr is None: raise gl.vm.UserError("No such round") if gl.message.sender_address != gr.creator and gl.message.sender_address != self.owner: raise gl.vm.UserError("Only creator or owner can close") if not gr.is_active: raise gl.vm.UserError("Already closed") gr.is_active = False self.grant_rounds[round_id] = gr @gl.public.view def get_grant_round(self, round_id: str) -> str: gr = self.grant_rounds.get(round_id, None) if gr is None: return "" return json.dumps({ "round_id": gr.round_id, "creator": gr.creator.as_hex, "title": gr.title, "description": gr.description, "judging_criteria": gr.judging_criteria, "created_at": int(gr.created_at), "is_active": gr.is_active, "proposal_deadline": int(gr.proposal_deadline), "review_deadline": int(gr.review_deadline), "max_winners": int(gr.max_winners) }) @gl.public.view def get_grant_round_count(self) -> int: return int(self.round_count) @gl.public.view def get_all_grant_round_ids(self) -> str: keys = [] for k in self.grant_rounds: keys.append(k) return json.dumps(keys) @gl.public.write def submit_proposal(self, proposal_id: str, round_id: str, title: str, summary: str, proposal_url: str): if self.paused: raise gl.vm.UserError("Paused") now = int(datetime.now(timezone.utc).timestamp()) # Validate round gr = self.grant_rounds.get(round_id, None) if gr is None: raise gl.vm.UserError("No such round") if not gr.is_active: raise gl.vm.UserError("Round closed") if now > int(gr.proposal_deadline): raise gl.vm.UserError("Proposal deadline passed") if self.seen_proposal_ids.get(proposal_id, 0) != 0: raise gl.vm.UserError("Duplicate proposal id") if not (1 <= len(proposal_id) <= 64): raise gl.vm.UserError("Invalid proposal_id") if not proposal_url.startswith("http"): raise gl.vm.UserError("Proposal URL must start with http") submitter = gl.message.sender_address prop = Proposal( proposal_id = proposal_id, round_id = round_id, submitter = submitter, title = title, summary = summary, proposal_url = proposal_url, submitted_at = u64(now), status = "SUBMITTED", ai_verdict = "", ai_score = 0, ai_reason_code = "", ai_reason = "", ai_confidence_band = "", appeal_tx_id = "", appealed = False, appeal_status = "NONE", appeal_verdict = "", appeal_reason_code = "", appeal_reason = "", appeal_confidence_band = "", final_status = "PENDING", reviewed_at = u64(0) ) self.proposals[proposal_id] = prop self.seen_proposal_ids[proposal_id] = u64(now) # index by round r_index = self.proposal_ids_by_round.get(round_id, DynArray[str]()) r_index.append(proposal_id) self.proposal_ids_by_round[round_id] = r_index # index by submitter s_index = self.proposal_ids_by_submitter.get(submitter, DynArray[str]()) s_index.append(proposal_id) self.proposal_ids_by_submitter[submitter] = s_index self.proposal_count += u256(1) @gl.public.view def get_proposal(self, proposal_id: str) -> str: prop = self.proposals.get(proposal_id, None) if prop is None: return "" return json.dumps({ "proposal_id": prop.proposal_id, "round_id": prop.round_id, "submitter": prop.submitter.as_hex, "title": prop.title, "summary": prop.summary, "proposal_url": prop.proposal_url, "submitted_at": int(prop.submitted_at), "status": prop.status, "ai_verdict": prop.ai_verdict, "ai_score": prop.ai_score, "ai_reason_code": prop.ai_reason_code, "ai_reason": prop.ai_reason, "ai_confidence_band": prop.ai_confidence_band, "appealed": prop.appealed, "appeal_status": prop.appeal_status, "appeal_verdict": prop.appeal_verdict, "appeal_reason_code": prop.appeal_reason_code, "appeal_reason": prop.appeal_reason, "appeal_confidence_band": prop.appeal_confidence_band, "final_status": prop.final_status, "reviewed_at": int(prop.reviewed_at) }) @gl.public.view def get_proposal_count(self) -> int: return int(self.proposal_count) @gl.public.view def get_proposals_by_round(self, round_id: str) -> str: ids = self.proposal_ids_by_round.get(round_id, DynArray[str]()) return json.dumps([p for p in ids]) @gl.public.view def get_proposals_by_submitter(self, submitter_hex: str) -> str: try: submitter = Address(submitter_hex) except: return "[]" ids = self.proposal_ids_by_submitter.get(submitter, DynArray[str]()) return json.dumps([p for p in ids]) @gl.public.write def ai_review_proposal(self, proposal_id: str): if self.paused: raise gl.vm.UserError("Paused") # Only one judgement per proposal (unless appealed) prop = self.proposals.get(proposal_id, None) if prop is None: raise gl.vm.UserError("No such proposal") if prop.status in ("JUDGED", "APPROVED", "REJECTED", "AWARDED"): raise gl.vm.UserError("Proposal already judged") if prop.status == "APPEALED": raise gl.vm.UserError("Proposal is in appeal; cannot auto-judge") gr = self.grant_rounds.get(prop.round_id, None) if gr is None: raise gl.vm.UserError("Grant round not found") if int(datetime.now(timezone.utc).timestamp()) < int(gr.proposal_deadline): raise gl.vm.UserError("Cannot judge before proposal deadline") if int(datetime.now(timezone.utc).timestamp()) > int(gr.review_deadline): raise gl.vm.UserError("Review deadline passed") proposal_title = prop.title proposal_summary = prop.summary proposal_url = prop.proposal_url judging_criteria = gr.judging_criteria TASK = ( "TASK:\n" "Review the following research funding proposal fairly and impartially, ONLY using the provided info.\n" "Judge per the supplied criteria, considering research quality, fit, novelty, feasibility, and clarity.\n" "REJECT if the proposal is unclear, incomplete, or unrelated to the criteria. ESCALATE if the evidence is ambiguous or missing.\n" ) RULES = ( "RULES:\n" "* Only use the proposal summary and linked URL as evidence—do not rely on world knowledge.\n" "* Decision enums must be: APPROVED, REJECTED, ESCALATED (uncertain), or UNDETERMINED (evidence missing).\n" "* Reason codes: CRITERIA_MET, CRITERIA_NOT_MET, UNCLEAR, INCOMPLETE, IRRELEVANT, INSUFFICIENT_EVIDENCE, OTHER.\n" "* Confidence_band: LOW, MEDIUM, HIGH. If unsure, use LOW.\n" "* Max ai_score: 100, min: 0. If rejecting, use <=49. If escalating/undetermined, set score=0.\n" "* Provide a short, 1-3 sentence reason suitable for display in a public dashboard. Be direct and factual.\n" "* Return only valid compact JSON with keys: verdict, reason_code, short_reason, ai_score, confidence_band.\n" ) CLAIM = ( f"CLAIM:\nProposal title: {proposal_title}\nSummary: {proposal_summary}\nFull proposal: {proposal_url}\n" ) CRIT = ( f"CRITERIA:\nJudging criteria for this round: {judging_criteria}\n" ) OUTPUT = ( "OUTPUT FORMAT:\n" '{"verdict":"APPROVED|REJECTED|ESCALATED|UNDETERMINED","reason_code":"CRITERIA_MET|CRITERIA_NOT_MET|UNCLEAR|INCOMPLETE|IRRELEVANT|INSUFFICIENT_EVIDENCE|OTHER","short_reason":"string <=256 chars","ai_score":int,"confidence_band":"LOW|MEDIUM|HIGH"}\n' 'NO markdown, NO explanation outside JSON, ONLY the JSON object.\n' ) prompt = "\n\n".join([TASK, RULES, CLAIM, CRIT, OUTPUT]) proposal_url_clipped = proposal_url[:500] def leader_fn(): # Fetch the proposal URL for additional evidence page = gl.nondet.web.get(proposal_url_clipped) page_body = "" if page.status_code == 200: page_body = page.body.decode("utf-8")[:1024] prompt2 = prompt + f"\nUNTRUSTED EVIDENCE from proposal URL (first 1024 chars):\n{page_body}\n" resp = gl.nondet.exec_prompt(prompt2, response_format="json") return resp def validator_fn(leaders_res: gl.vm.Return): # Field shape: parse/validate verdict, reason_code, ai_score, confidence_band, short_reason res = leaders_res.calldata if isinstance(leaders_res, gl.vm.Return) else leaders_res # Defensive if not isinstance(res, dict): return False verdict = str(res.get("verdict","")).upper() reason_code = str(res.get("reason_code","")) short_reason = str(res.get("short_reason","")) ai_score = res.get("ai_score", 0) confidence_band = str(res.get("confidence_band", "")) valid_verdicts = {"APPROVED","REJECTED","ESCALATED","UNDETERMINED"} valid_codes = {"CRITERIA_MET","CRITERIA_NOT_MET","UNCLEAR","INCOMPLETE","IRRELEVANT","INSUFFICIENT_EVIDENCE","OTHER"} valid_bands = {"LOW","MEDIUM","HIGH"} if verdict not in valid_verdicts: return False if reason_code not in valid_codes: return False if confidence_band not in valid_bands: return False if not (0 <= int(ai_score) <= 100): return False if not (0 < len(short_reason) <= 256): return False # On APPROVED, require score >=50 if verdict=="APPROVED" and int(ai_score)<50: return False # On REJECTED, require score <=49 if verdict=="REJECTED" and int(ai_score)>49: return False # On ESCALATED/UNDETERMINED, require score==0 if verdict in ("ESCALATED","UNDETERMINED") and int(ai_score)!=0: return False return True result = gl.vm.run_nondet_unsafe(leader_fn, validator_fn) now = int(datetime.now(timezone.utc).timestamp()) # Save decision = result if isinstance(result, dict) else {} verdict = str(decision.get("verdict","")).upper() ai_score = int(decision.get("ai_score",0)) reason_code = str(decision.get("reason_code","")) reason = str(decision.get("short_reason","")) band = str(decision.get("confidence_band","")) # Defensive: do not approve on invalid verdict if verdict not in ("APPROVED","REJECTED","ESCALATED","UNDETERMINED"): verdict = "ESCALATED" # Store prop.status = "JUDGED" if verdict=="APPROVED" else ("REJECTED" if verdict=="REJECTED" else "ESCALATED") prop.ai_verdict = verdict prop.ai_score = ai_score prop.ai_reason_code = reason_code prop.ai_reason = reason prop.ai_confidence_band = band prop.reviewed_at = u64(now) if verdict in ("ESCALATED","UNDETERMINED"): prop.final_status = "PENDING" else: prop.final_status = "FINAL" self.proposals[proposal_id] = prop @gl.public.write def appeal_proposal(self, proposal_id: str, appeal_tx_id: str): if self.paused: raise gl.vm.UserError("Paused") prop = self.proposals.get(proposal_id, None) if prop is None: raise gl.vm.UserError("No such proposal") # Only submitter can appeal, only once, only if actually rejected if prop.submitter != gl.message.sender_address: raise gl.vm.UserError("Only submitter may appeal") if prop.appealed: raise gl.vm.UserError("Appeal already submitted") if prop.status not in ("REJECTED", "ESCALATED"): raise gl.vm.UserError("Can only appeal a rejected or escalated proposal") prop.appealed = True prop.appeal_status = "PENDING" prop.appeal_tx_id = appeal_tx_id self.proposals[proposal_id] = prop @gl.public.write def ai_review_appeal(self, proposal_id: str): if self.paused: raise gl.vm.UserError("Paused") prop = self.proposals.get(proposal_id, None) if prop is None: raise gl.vm.UserError("No such proposal") if not prop.appealed or prop.appeal_status != "PENDING": raise gl.vm.UserError("No pending appeal") gr = self.grant_rounds.get(prop.round_id, None) if gr is None: raise gl.vm.UserError("Grant round not found") TASK = ( "TASK:\n" "Review this proposal's appeal ONLY using the documented evidence and the initial rejection reason.\n" "Either confirm the rejection, approve on new evidence, or escalate if unclear.\n" ) RULES = ( "RULES:\n" "* Enums: APPROVED, REJECTED, ESCALATED.\n" "* Reason codes: APPEAL_CRITERIA_MET, APPEAL_CRITERIA_NOT_MET, STILL_UNCLEAR, STILL_IRRELEVANT, INSUFFICIENT_NEW_EVIDENCE, OTHER.\n" "* Confidence_band: LOW, MEDIUM, HIGH\n" "* If appeal is APPROVED, raise ai_score=50-100; if REJECTED, ai_score=0-49; ESCALATED, ai_score=0.\n" "* Return only valid JSON: {verdict, reason_code, short_reason, ai_score, confidence_band}\n" "* Do NOT approve unless strong new evidence is provided (e.g. via appeal_tx_id or URL update).\n" ) EVIDENCE = ( f"CLAIM:\nProposal: {prop.title}, originally rejected because: {prop.ai_reason}\nAppeal evidence (tx_id): {prop.appeal_tx_id}\nProposal URL: {prop.proposal_url}\n" ) CRIT = f"CRITERIA:\n{gr.judging_criteria}\n" OUTPUT = ( "OUTPUT FORMAT:\n" '{"verdict":"APPROVED|REJECTED|ESCALATED","reason_code":"APPEAL_CRITERIA_MET|APPEAL_CRITERIA_NOT_MET|STILL_UNCLEAR|STILL_IRRELEVANT|INSUFFICIENT_NEW_EVIDENCE|OTHER","short_reason":"string <=256 chars","ai_score":int,"confidence_band":"LOW|MEDIUM|HIGH"}\n' "NO markdown. ONLY valid JSON." ) proposal_url_clipped = prop.proposal_url[:500] def leader_fn(): page = gl.nondet.web.get(proposal_url_clipped) page_body = "" if page.status_code == 200: page_body = page.body.decode("utf-8")[:1024] prompt2 = "\n\n".join([TASK, RULES, EVIDENCE, CRIT, OUTPUT]) + f"\nUNTRUSTED EVIDENCE from proposal URL (first 1024 chars):\n{page_body}\n" return gl.nondet.exec_prompt(prompt2, response_format="json") def validator_fn(leaders_res: gl.vm.Return): res = leaders_res.calldata if isinstance(leaders_res, gl.vm.Return) else leaders_res if not isinstance(res, dict): return False verdict = str(res.get("verdict", "")).upper() reason_code = str(res.get("reason_code", "")) short_reason = str(res.get("short_reason", "")) ai_score = int(res.get("ai_score", 0)) confidence_band = str(res.get("confidence_band", "")) allowed_v = {"APPROVED","REJECTED","ESCALATED"} allowed_r = {"APPEAL_CRITERIA_MET","APPEAL_CRITERIA_NOT_MET","STILL_UNCLEAR","STILL_IRRELEVANT","INSUFFICIENT_NEW_EVIDENCE","OTHER"} allowed_b = {"LOW","MEDIUM","HIGH"} if verdict not in allowed_v: return False if reason_code not in allowed_r: return False if confidence_band not in allowed_b: return False if not (0 <= ai_score <= 100): return False if not (0 < len(short_reason) <= 256): return False if verdict=="APPROVED" and ai_score<50: return False if verdict=="REJECTED" and ai_score>49: return False if verdict=="ESCALATED" and ai_score!=0: return False return True decision = gl.vm.run_nondet_unsafe(leader_fn, validator_fn) now = int(datetime.now(timezone.utc).timestamp()) decision = decision if isinstance(decision, dict) else {} verdict = str(decision.get("verdict", "")).upper() ai_score = int(decision.get("ai_score", 0)) reason_code = str(decision.get("reason_code", "")) reason = str(decision.get("short_reason", "")) band = str(decision.get("confidence_band", "")) if verdict not in ("APPROVED","REJECTED","ESCALATED"): verdict = "ESCALATED" prop.appeal_status = verdict prop.appeal_verdict = verdict prop.appeal_reason_code = reason_code prop.appeal_reason = reason prop.appeal_confidence_band = band # Post-appeal, update status and final_status if verdict=="APPROVED": prop.status = "APPROVED" prop.final_status = "FINAL" prop.ai_verdict = "APPROVED" prop.ai_score = ai_score prop.ai_reason_code = reason_code prop.ai_reason = reason prop.ai_confidence_band = band elif verdict=="REJECTED": prop.status = "REJECTED" prop.final_status = "FINAL" elif verdict in ("ESCALATED",): prop.status = "ESCALATED" prop.final_status = "PENDING" self.proposals[prop.proposal_id] = prop @gl.public.view def get_recommended_winners(self, round_id: str) -> str: # Return up to round.max_winners proposals in APPROVED state, ordered by ai_score desc gr = self.grant_rounds.get(round_id, None) if gr is None: return "[]" ids = self.proposal_ids_by_round.get(round_id, DynArray[str]()) proposals = [] for pid in ids: p = self.proposals.get(pid, None) if p is None: continue # Use post-appeal verdict where available is_approved = ( (p.status == "APPROVED" and p.final_status == "FINAL") ) if is_approved: proposals.append({ "proposal_id": p.proposal_id, "ai_score": p.ai_score }) # Sort by score desc proposals.sort(key=lambda x: x["ai_score"], reverse=True) winners = proposals[:int(gr.max_winners)] return json.dumps([w["proposal_id"] for w in winners]) @gl.public.view def get_all_proposals_statuses(self, round_id: str) -> str: ids = self.proposal_ids_by_round.get(round_id, DynArray[str]()) out = [] for pid in ids: p = self.proposals.get(pid, None) if p is None: continue out.append({ "proposal_id": p.proposal_id, "status": p.status, "ai_verdict": p.ai_verdict, "ai_score": p.ai_score, "appealed": p.appealed, "appeal_status": p.appeal_status, "final_status": p.final_status }) return json.dumps(out)