# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from dataclasses import dataclass from genlayer import * import json @allow_storage @dataclass class Job: id: str title: str spec: str deliverable_format: str budget: bigint poster: str agent: str status: str deliverable: str verdict: str score: bigint judgment_reason: str created_at: bigint deadline: bigint completed_at: bigint dispute_round: bigint task_type: str policy: str category: str @allow_storage @dataclass class AgentStats: completed: bigint approved: bigint rejected: bigint partial: bigint total_earned: bigint score_sum: bigint disputes: bigint delivery_time_sum: bigint JOB_CATEGORIES = ( "SOFTWARE", "RESEARCH", "WRITING", "DESIGN", "DATA", "BUSINESS", "PROFESSIONAL_SERVICES", "EDUCATION", "MARKETING", "CUSTOMER_SUPPORT", "DIGITAL_ACTIONS", "PHYSICAL_SERVICES", "AI_AGENT", "OTHER", ) # Categories accepted by earlier frontend versions. They are still valid on # post (backward compatibility for existing clients) and are resolved to the # general taxonomy when judging. Stored jobs keep their original value. LEGACY_JOB_CATEGORIES = ("GENERAL", "CODE", "CONTENT", "WEB") ACCEPTED_JOB_CATEGORIES = JOB_CATEGORIES + LEGACY_JOB_CATEGORIES LEGACY_CATEGORY_MAP = { "GENERAL": "OTHER", "CODE": "SOFTWARE", "CONTENT": "WRITING", "WEB": "SOFTWARE", "DATA": "DATA", "RESEARCH": "RESEARCH", } def _resolve_category(category: str) -> str: """Map any accepted category (new or legacy) to the general taxonomy.""" if not category: return "OTHER" return LEGACY_CATEGORY_MAP.get(category, category) DEFAULT_MIN_SCORE = 75 def _parse_verification_plan(policy: str) -> dict: """Parse the machine-readable parts of a verification-plan policy string. The policy is a `|`-separated list of `KEY:value` segments produced by the frontend serializer (free-text NOTES/ACC/GOAL segments are passed through to the judge prompt untouched). Unknown keys and malformed values are ignored so hand-written policies keep working. Recognized keys: MIN_SCORE:n — minimum score for APPROVED (clamped to 30..100) GATES:a+b — hard gates enforced deterministically before consensus: `url` (deliverable URL must be reachable) and `sources` (all claim sources must be reachable) """ plan = {"min_score": DEFAULT_MIN_SCORE, "gates": set()} if not policy: return plan for segment in policy.split("|"): segment = segment.strip() if ":" not in segment: continue key, _, value = segment.partition(":") key = key.strip().upper() value = value.strip() if key == "MIN_SCORE": try: plan["min_score"] = max(30, min(100, int(value))) except ValueError: pass elif key == "GATES": for gate in value.replace("+", ",").split(","): gate = gate.strip().lower() if gate: plan["gates"].add(gate) return plan CATEGORY_CONTEXTS = { "SOFTWARE": """This is a SOFTWARE task. Evaluate the delivered outcome against the spec: functional completeness, correctness signals visible in the fetched content (repository structure, documentation, tests), and any deployment or execution evidence provided. Judge what was achieved, not the tools used.""", "RESEARCH": """This is a RESEARCH task. Evaluate research rigor: coverage of the questions posed in the spec, factual consistency across claims, quality of cited sources, and whether conclusions are traceable to evidence.""", "WRITING": """This is a WRITING task. Evaluate the written material against the brief: structure, factual accuracy, tone consistency, and completeness of everything the spec requested.""", "DESIGN": """This is a DESIGN task. Evaluate the creative deliverable against the brief: compliance with stated requirements (assets, formats, brand constraints), quality signals, and completeness of what was requested.""", "DATA": """This is a DATA task. Evaluate dataset integrity: schema conformance, row counts, missing values, format consistency, and coverage of the requested fields.""", "BUSINESS": """This is a BUSINESS task. Evaluate whether the stated business outcome was achieved: completeness of the requested analysis, artifacts or actions, professional quality, and alignment with the objective in the spec.""", "PROFESSIONAL_SERVICES": """This is a PROFESSIONAL SERVICES task. Evaluate domain correctness, completeness of the engagement described in the spec, adherence to any cited standards, and whether the work is documented.""", "EDUCATION": """This is an EDUCATION task. Evaluate coverage of the learning objectives in the spec, factual accuracy, clarity of explanation, and completeness of the promised materials.""", "MARKETING": """This is a MARKETING task. Evaluate compliance with the brief (audience, message, brand constraints), completeness of the campaign assets requested, and overall quality signals.""", "CUSTOMER_SUPPORT": """This is a CUSTOMER SUPPORT task. Evaluate whether the stated issue was resolved correctly and completely, and whether the follow-through evidence supports the claimed resolution.""", "DIGITAL_ACTIONS": """This is a DIGITAL ACTIONS task. Evaluate verifiable completion of the requested on-chain or off-chain actions: transaction proofs, resulting state, correctness of parameters, and completeness.""", "PHYSICAL_SERVICES": """This is a PHYSICAL SERVICES task. Evaluate completion evidence: photos, confirmations, receipts or other proof that the service was performed as specified (location, materials, scope).""", "AI_AGENT": """This is an AI AGENT task. Evaluate workflow completion: each requested step executed, correct tool or output behavior, and logs or evidence showing what the agent did.""", "OTHER": """This is a general task. Evaluate whether the agreed outcome was achieved: the acceptance criteria in the spec are satisfied and the provided evidence is sufficient to prove completion.""", } def _default_agent_stats() -> dict: return { "completed": 0, "approved": 0, "rejected": 0, "partial": 0, "total_earned": 0, "score_sum": 0, "disputes": 0, "delivery_time_sum": 0, } class AgentPact(gl.Contract): jobs: TreeMap[str, Job] job_sources: TreeMap[str, str] # job_id -> comma-separated sources verifications: TreeMap[str, str] # job_id -> JSON-encoded list of VerificationRecord dicts agent_stats: TreeMap[str, AgentStats] total_escrowed: bigint total_released: bigint open_job_ids: DynArray[str] all_job_ids: DynArray[str] platform_fee_bps: bigint def __init__(self): pass @gl.public.write.payable def post_job( self, title: str, spec: str, deliverable_format: str, deadline_blocks: int, policy: str = "", category: str = "GENERAL", ) -> str: if not title or len(title) > 80: raise gl.vm.UserError("Title must be non-empty and 80 characters or fewer") if not spec or len(spec) > 2000: raise gl.vm.UserError("Spec must be non-empty and 2000 characters or fewer") if deliverable_format not in ["url", "text", "github_url"]: raise gl.vm.UserError("deliverable_format must be one of: url, text, github_url") if deadline_blocks <= 0 or deadline_blocks > 302400: raise gl.vm.UserError("deadline_blocks must be between 1 and 302400") if len(policy) > 500: raise gl.vm.UserError("Policy must be 500 characters or fewer") if category not in ACCEPTED_JOB_CATEGORIES: raise gl.vm.UserError( "category must be one of: " + ", ".join(JOB_CATEGORIES) + " (legacy GENERAL, CODE, CONTENT, WEB also accepted)" ) if gl.message.value <= 0: raise gl.vm.UserError("Budget must be greater than 0") job_id = gl.message.sender_address + "_" + str(gl.block.number) + "_" + str(gl.block.timestamp) deadline = gl.block.timestamp + (deadline_blocks * 8) job = Job( id=job_id, title=title, spec=spec, deliverable_format=deliverable_format, budget=gl.message.value, poster=gl.message.sender_address, agent="", status="OPEN", deliverable="", verdict="", score=0, judgment_reason="", created_at=gl.block.timestamp, deadline=deadline, completed_at=0, dispute_round=0, task_type="TASK", policy=policy, category=category, ) self.jobs[job_id] = job self.open_job_ids.append(job_id) self.all_job_ids.append(job_id) self.total_escrowed += gl.message.value gl.emit( "job_posted", { "job_id": job_id, "poster": job.poster, "title": job.title, "budget": job.budget, "status": job.status, }, ) return job_id @gl.public.write.payable def post_claim( self, claim: str, sources: DynArray[str], deadline_blocks: int, policy: str = "", ) -> str: if not claim or len(claim) > 2000: raise gl.vm.UserError("Claim must be non-empty and 2000 characters or fewer") if not isinstance(sources, list) or len(sources) == 0: raise gl.vm.UserError("At least one source URL is required") if len(sources) > 10: raise gl.vm.UserError("Maximum 10 sources allowed") for src in sources: if not isinstance(src, str) or not src.startswith("https://"): raise gl.vm.UserError("All source URLs must start with https://") if len(policy) > 500: raise gl.vm.UserError("Policy must be 500 characters or fewer") if deadline_blocks <= 0 or deadline_blocks > 302400: raise gl.vm.UserError("deadline_blocks must be between 1 and 302400") if gl.message.value <= 0: raise gl.vm.UserError("Budget must be greater than 0") job_id = gl.message.sender_address + "_" + str(gl.block.number) + "_" + str(gl.block.timestamp) deadline = gl.block.timestamp + (deadline_blocks * 8) title = ("VERIFY CLAIM: " + claim)[:80] job = Job( id=job_id, title=title, spec=claim, deliverable_format="text", budget=gl.message.value, poster=gl.message.sender_address, agent="", status="OPEN", deliverable="", verdict="", score=0, judgment_reason="", created_at=gl.block.timestamp, deadline=deadline, completed_at=0, dispute_round=0, task_type="CLAIM", policy=policy, category="GENERAL", ) self.jobs[job_id] = job self.job_sources[job_id] = ",".join(sources) self.open_job_ids.append(job_id) self.all_job_ids.append(job_id) self.total_escrowed += gl.message.value return job_id @gl.public.write def accept_job(self, job_id: str) -> None: if job_id not in self.jobs: raise gl.vm.UserError("Job not found") job = self.jobs[job_id] if job.status != "OPEN": raise gl.vm.UserError("Job is not available for acceptance") if gl.message.sender_address == job.poster: raise gl.vm.UserError("Poster cannot accept their own job") if gl.block.timestamp > job.deadline: raise gl.vm.UserError("Job deadline has passed") job.agent = gl.message.sender_address job.status = "ACTIVE" self.open_job_ids.remove(job_id) self.jobs[job_id] = job gl.emit( "job_accepted", { "job_id": job_id, "poster": job.poster, "agent": job.agent, "title": job.title, "status": job.status, }, ) @gl.public.write def submit_deliverable(self, job_id: str, deliverable: str) -> None: if job_id not in self.jobs: raise gl.vm.UserError("Job not found") job = self.jobs[job_id] if job.status != "ACTIVE": raise gl.vm.UserError("Job is not in ACTIVE status") if gl.message.sender_address != job.agent: raise gl.vm.UserError("Only the assigned agent can submit deliverables") if not deliverable: raise gl.vm.UserError("Deliverable cannot be empty") if job.deliverable_format in ["url", "github_url"]: if not deliverable.startswith("https://"): raise gl.vm.UserError("URL deliverables must start with https://") if gl.block.timestamp > job.deadline: raise gl.vm.UserError("Job deadline has passed") job.deliverable = deliverable job.status = "SUBMITTED" self.jobs[job_id] = job gl.emit( "deliverable_submitted", { "job_id": job_id, "agent": job.agent, "deliverable": deliverable, "status": job.status, }, ) self._judge_deliverable(job_id) @gl.public.write def dispute_verdict(self, job_id: str) -> None: if job_id not in self.jobs: raise gl.vm.UserError("Job not found") job = self.jobs[job_id] if job.status != "COMPLETE": raise gl.vm.UserError("Job must be COMPLETE to dispute") if gl.message.sender_address != job.poster and gl.message.sender_address != job.agent: raise gl.vm.UserError("Only poster or agent can dispute") if job.dispute_round >= 3: raise gl.vm.UserError("Maximum dispute rounds reached") blocks_since_completion = gl.block.timestamp - job.completed_at if blocks_since_completion > 860: raise gl.vm.UserError("Dispute window has passed") job.dispute_round += 1 job.status = "DISPUTED" if job.agent in self.agent_stats: self.agent_stats[job.agent].disputes += 1 self.jobs[job_id] = job gl.emit( "verdict_disputed", { "job_id": job_id, "poster": job.poster, "agent": job.agent, "title": job.title, "previous_verdict": job.verdict, "previous_score": job.score, "round": job.dispute_round, "status": job.status, }, ) self._judge_deliverable(job_id) @gl.public.write def cancel_job(self, job_id: str) -> None: if job_id not in self.jobs: raise gl.vm.UserError("Job not found") job = self.jobs[job_id] if job.status != "OPEN": raise gl.vm.UserError("Only OPEN jobs can be cancelled") if gl.message.sender_address != job.poster: raise gl.vm.UserError("Only the poster can cancel") job.status = "CANCELLED" self.open_job_ids.remove(job_id) self.jobs[job_id] = job gl.emit( "job_cancelled", { "job_id": job_id, "poster": job.poster, "title": job.title, "budget": job.budget, "status": job.status, }, ) gl.transfer(job.poster, job.budget) self.total_escrowed -= job.budget @gl.public.view def get_job(self, job_id: str) -> dict: if job_id not in self.jobs: raise gl.vm.UserError("Job not found") j = self.jobs[job_id] return { "id": j.id, "title": j.title, "spec": j.spec, "deliverable_format": j.deliverable_format, "budget": j.budget, "poster": j.poster, "agent": j.agent, "status": j.status, "deliverable": j.deliverable, "verdict": j.verdict, "score": j.score, "judgment_reason": j.judgment_reason, "created_at": j.created_at, "deadline": j.deadline, "completed_at": j.completed_at, "dispute_round": j.dispute_round, "task_type": j.task_type, "policy": j.policy, "category": j.category, } @gl.public.view def get_open_jobs(self, limit: int = 20) -> list: if limit > 50: limit = 50 result = [] for i in range(len(self.open_job_ids) - 1, -1, -1): if len(result) >= limit: break job_id = self.open_job_ids[i] j = self.jobs[job_id] result.append({ "id": j.id, "title": j.title, "spec": j.spec, "deliverable_format": j.deliverable_format, "budget": j.budget, "poster": j.poster, "agent": j.agent, "status": j.status, "deliverable": j.deliverable, "verdict": j.verdict, "score": j.score, "judgment_reason": j.judgment_reason, "created_at": j.created_at, "deadline": j.deadline, "completed_at": j.completed_at, "dispute_round": j.dispute_round, "task_type": j.task_type, "policy": j.policy, "category": j.category, }) return result @gl.public.view def get_all_jobs(self, limit: int = 50) -> list: if limit > 100: limit = 100 result = [] for i in range(len(self.all_job_ids) - 1, -1, -1): if len(result) >= limit: break job_id = self.all_job_ids[i] j = self.jobs[job_id] result.append({ "id": j.id, "title": j.title, "spec": j.spec, "deliverable_format": j.deliverable_format, "budget": j.budget, "poster": j.poster, "agent": j.agent, "status": j.status, "deliverable": j.deliverable, "verdict": j.verdict, "score": j.score, "judgment_reason": j.judgment_reason, "created_at": j.created_at, "deadline": j.deadline, "completed_at": j.completed_at, "dispute_round": j.dispute_round, "task_type": j.task_type, "policy": j.policy, "category": j.category, }) return result @gl.public.view def get_verification(self, job_id: str) -> dict: if job_id not in self.verifications or not self.verifications[job_id]: raise gl.vm.UserError("No verification found for this job") records = json.loads(self.verifications[job_id]) if not records: raise gl.vm.UserError("No verification found for this job") return records[-1] @gl.public.view def get_verifications(self, job_id: str) -> list: if job_id not in self.verifications or not self.verifications[job_id]: return [] return json.loads(self.verifications[job_id]) @gl.public.view def get_agent_stats(self, agent_address: str) -> dict: if agent_address in self.agent_stats: s = self.agent_stats[agent_address] return { "completed": s.completed, "approved": s.approved, "rejected": s.rejected, "partial": s.partial, "total_earned": s.total_earned, "score_sum": s.score_sum, "disputes": s.disputes, "delivery_time_sum": s.delivery_time_sum, } return _default_agent_stats() @gl.public.view def get_platform_stats(self) -> dict: return { "total_escrowed": self.total_escrowed, "total_released": self.total_released, "total_jobs": len(self.jobs), "open_jobs_count": len(self.open_job_ids), } def _collect_evidence(self, job: Job, deliverable_content: str) -> list: evidence = [] fetch_failed = "[Could not fetch" in deliverable_content if job.deliverable_format in ["url", "github_url"]: evidence.append( { "label": "Deliverable URL reachable", "passed": not fetch_failed, } ) if job.deliverable_format == "github_url": evidence.append( { "label": "Repository hosted on github.com", "passed": "github.com" in job.deliverable.lower(), } ) content_lower = deliverable_content.lower() spec_tokens = set() for token in job.spec.lower().replace("\n", " ").split(" "): cleaned = "".join(c for c in token if c.isalnum()) if len(cleaned) >= 5 and cleaned not in ( "about", "should", "would", "there", "their", "which", "these", "those", "where", "using", "based", "must", "with", "that", "this", "from", "have", "will", ): spec_tokens.add(cleaned) if len(spec_tokens) >= 5: break for token in sorted(spec_tokens)[:5]: evidence.append( { "label": f"Spec keyword '{token}' present in deliverable", "passed": token in content_lower, } ) if job.deliverable_format == "text": evidence.append( { "label": "Deliverable meets minimum length (50 chars)", "passed": len(deliverable_content.strip()) >= 50, } ) return evidence def _fetch_claim_sources(self, job: Job): source_texts = [] source_evidence = [] sources_str = self.job_sources.get(job.id, "") sources = sources_str.split(",") if sources_str else [] for idx, src in enumerate(sources[:5], start=1): try: text = gl.get_webpage(src, mode="text")[:1500] fetched = "[Could not fetch" not in text and len(text.strip()) > 0 source_texts.append(f"SOURCE {idx} ({src}):\n{text}") except Exception: text = "" fetched = False source_texts.append(f"SOURCE {idx} ({src}): [Could not fetch source]") source_evidence.append( { "label": f"Source #{idx} accessible ({src})", "passed": fetched, "source": src, "source_index": idx, } ) return "\n\n".join(source_texts), source_evidence def _judge_deliverable(self, job_id: str) -> None: job = self.jobs[job_id] deliverable_content = "" evidence = [] if job.task_type == "CLAIM": deliverable_content, source_evidence = self._fetch_claim_sources(job) evidence.extend(source_evidence) elif job.deliverable_format in ["url", "github_url"]: try: deliverable_content = gl.get_webpage(job.deliverable, mode="text")[:3000] except Exception: deliverable_content = "[Could not fetch URL - treating as submission failure]" else: deliverable_content = job.deliverable[:3000] evidence.extend(self._collect_evidence(job, deliverable_content)) plan = _parse_verification_plan(job.policy) min_score = plan["min_score"] # Deterministic hard gates run BEFORE consensus: a failed gate rejects # the deliverable without spending validator consensus on it. gate_failure = None if "url" in plan["gates"] and job.deliverable_format in ["url", "github_url"]: url_ok = any( e.get("label") == "Deliverable URL reachable" and e.get("passed") for e in evidence if isinstance(e, dict) ) if not url_ok: gate_failure = ( "Hard gate failed: the deliverable URL is unreachable, " "but the verification plan requires a reachable URL." ) if "sources" in plan["gates"] and job.task_type == "CLAIM": dead_source = any( "accessible" in e.get("label", "") and not e.get("passed") for e in evidence if isinstance(e, dict) ) if dead_source: gate_failure = ( "Hard gate failed: one or more claim sources are unreachable, " "but the verification plan requires all sources to be reachable." ) dispute_context = "" if job.dispute_round > 0: dispute_context = f""" NOTE: This is dispute round {job.dispute_round}. The previous verdict was: {job.verdict} (score: {job.score}/100). Previous reasoning: {job.judgment_reason} Apply higher scrutiny. Consider edge cases and partial completion. """ policy_context = "" if job.policy: policy_context = f""" ADDITIONAL VERIFICATION POLICY defined by the job creator: {job.policy} You MUST evaluate the deliverable against these custom criteria. """ claim_context = "" if job.task_type == "CLAIM": claim_context = """ This is a CLAIM VERIFICATION job. An independent researcher reviewed the sources above and submitted a conclusion. Evaluate whether their conclusion is supported by the source material. A valid deliverable states a verdict (TRUE, FALSE, MISLEADING, or UNVERIFIABLE) with reasoning grounded in the sources. """ category_context = "" if job.task_type == "TASK": resolved = _resolve_category(job.category) if resolved in CATEGORY_CONTEXTS: category_context = CATEGORY_CONTEXTS[resolved] plan_context = f""" VERIFICATION PLAN (enforced deterministically — your verdict MUST respect it): - Minimum approval score: {min_score}. APPROVED requires score >= {min_score}. - Hard gates already evaluated mechanically (see EVIDENCE CHECKS above). """ if min_score <= 30: partial_rule = "PARTIAL: not applicable at this minimum score (scores below 30 are REJECTED)." else: partial_rule = ( f"PARTIAL (score 30-{min_score - 1}): " "Partial payment based on release_percentage." ) if gate_failure is not None: parsed = { "verdict": "REJECTED", "score": 0, "judgment_reason": gate_failure, "release_percentage": 0, } else: try: result = gl.exec_prompt( f""" You are a neutral, expert judge evaluating whether delivered work satisfies the agreed task to the standard described below. You are simulating a panel of 3 independent validators reaching consensus. JOB TITLE: {job.title} JOB SPEC (what was agreed to be delivered): {job.spec} DELIVERABLE FORMAT EXPECTED: {job.deliverable_format} DELIVERABLE SUBMITTED: {job.deliverable} REFERENCE CONTENT (fetched from URL/sources if applicable): {deliverable_content} EVIDENCE CHECKS already performed mechanically: {json.dumps(evidence)} {policy_context} {plan_context} {claim_context} {category_context} {dispute_context} Evaluate whether the deliverable satisfies the job spec. Respond ONLY with a valid JSON object using exactly this structure: {{ "verdict": "APPROVED" | "REJECTED" | "PARTIAL", "score": , "judgment_reason": "<2-4 sentences explaining the verdict>", "release_percentage": , "validators": [ {{"id": 1, "verdict": "APPROVED" | "REJECTED" | "PARTIAL", "score": }}, {{"id": 2, "verdict": "APPROVED" | "REJECTED" | "PARTIAL", "score": }}, {{"id": 3, "verdict": "APPROVED" | "REJECTED" | "PARTIAL", "score": }} ] }} Rules: - APPROVED (score {min_score}-100): Full payment released. - {partial_rule} - REJECTED (score 0-29): No payment released. - The validators array represents 3 independent assessments. Their scores should vary slightly (within ±8 of the final score). The majority verdict among them must match the final verdict. - Return ONLY the JSON, no markdown, no preamble. """ ) parsed = json.loads(result.replace("```json", "").replace("```", "")) except Exception: parsed = { "verdict": "REJECTED", "score": 0, "judgment_reason": "Judge failed to evaluate deliverable", "release_percentage": 0, } job.verdict = parsed.get("verdict", "REJECTED") job.score = parsed.get("score", 0) job.judgment_reason = parsed.get("judgment_reason", "Evaluation failed") release_pct = parsed.get("release_percentage", 0) if job.verdict == "APPROVED" and job.score < min_score: # Deterministic enforcement: consensus cannot approve below the # plan's minimum score — downgrade to PARTIAL instead. job.verdict = "PARTIAL" job.judgment_reason = ( f"Score {job.score} is below the required minimum of {min_score}; " f"downgraded to PARTIAL. {job.judgment_reason}" ) release_pct = max(10, min(90, job.score)) if job.verdict == "APPROVED": release_pct = 100 elif job.verdict == "REJECTED": release_pct = 0 elif job.verdict == "PARTIAL": release_pct = max(10, min(90, release_pct)) validators = parsed.get("validators") if ( not isinstance(validators, list) or len(validators) == 0 or not all(isinstance(v, dict) and "verdict" in v and "score" in v for v in validators) ): validators = [{"id": i + 1, "verdict": job.verdict, "score": job.score} for i in range(3)] consensus_score = sum(int(v["score"]) for v in validators) / len(validators) record_dict = { "round": job.dispute_round, "verdict": job.verdict, "score": job.score, "judgment_reason": job.judgment_reason, "release_percentage": release_pct, "consensus_score": consensus_score, "timestamp": gl.block.timestamp, "deliverable": job.deliverable, "spec": job.spec, "validators": validators, "evidence": evidence, } existing = [] if job_id in self.verifications and self.verifications[job_id]: existing = json.loads(self.verifications[job_id]) existing.append(record_dict) self.verifications[job_id] = json.dumps(existing) platform_fee = (job.budget * self.platform_fee_bps) // 10000 net_budget = job.budget - platform_fee release_amount = (net_budget * release_pct) // 100 refund_amount = net_budget - release_amount if release_amount > 0: gl.transfer(job.agent, release_amount) self.total_released += release_amount if job.agent in self.agent_stats: stats = self.agent_stats[job.agent] else: stats = AgentStats( completed=0, approved=0, rejected=0, partial=0, total_earned=0, score_sum=0, disputes=0, delivery_time_sum=0, ) stats.completed += 1 verdict_key = job.verdict.lower() if verdict_key == "approved": stats.approved += 1 elif verdict_key == "rejected": stats.rejected += 1 elif verdict_key == "partial": stats.partial += 1 stats.total_earned += release_amount stats.score_sum += job.score stats.delivery_time_sum += max( 0, gl.block.timestamp - job.created_at ) self.agent_stats[job.agent] = stats if refund_amount > 0: gl.transfer(job.poster, refund_amount) if platform_fee > 0: gl.transfer(gl.contract_address, platform_fee) gl.emit( "verdict_finalized", { "job_id": job_id, "poster": job.poster, "agent": job.agent, "title": job.title, "budget": job.budget, "verdict": job.verdict, "score": job.score, "release_percentage": release_pct, "release_amount": release_amount, "refund_amount": refund_amount, "platform_fee": platform_fee, "round": job.dispute_round, "status": "COMPLETE", "timestamp": gl.block.timestamp, }, ) job.status = "COMPLETE" job.completed_at = gl.block.timestamp self.jobs[job_id] = job