# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } # ═══════════════════════════════════════════════════════════════════════════════ # Veritas Layer — VeritasCore (Phase II — Production) # # Execution heart of the protocol. Manages the complete task lifecycle: # # submit(...) — validate inputs, verify snapshot hash, store task PENDING # evaluate(...) — run nondet LLM evaluation, store result, update history # finalize(...) — seal task permanently (submitter-only) # mark_disputed() — transition EVALUATED → DISPUTED (DisputeLedger-only) # configure(...) — one-time deployer-only address configuration # # Phase II changes over Phase I: # + deployer / dispute_ledger_address / is_configured (access control) # + configure() — one-time deployment step linking the three contracts # + mark_disputed() now enforces dispute_ledger_address == msg.sender # + submit() snapshot_hash self-verification (no cross-contract call) # + submit() validates require_inline_content flag from module snapshot # + ModuleSnapshot extended: snapshot_hash, max_dispute_rounds, # challenge_window_sec, require_inline_content # + eval_history: DynArray[EvalRecord, 4] on Task (audit trail per task) # + MAX_FILLED_PROMPT_LEN cap applied inside leader_fn (timeout mitigation) # + UNCERTAIN gate in validator_fn uses borderline tolerance (escalation fix) # + score_tolerance acts as the validator agreement band in validator_fn # # Nondet execution pattern (from sample contract source truth): # gl.eq_principle.prompt_comparative(leader_fn, criteria_str) # This is the correct production pattern — not gl.vm.run_nondet_unsafe. # leader_fn returns a JSON string (sort_keys=True). # criteria_str instructs validators on numeric equivalence check. # Validators independently run leader_fn and compare numerically. # # GenLayer compliance: # E011 — one gl.Contract subclass per file PASS # E014 — @allow_storage on all storage dataclasses PASS # E015 — no bare int/float in storage fields PASS # E016 — no list/dict in storage fields PASS # E018 — TreeMap keys valid {str,Address,u256,u32,...} PASS # E024 — no get_contract_at inside nondet closures PASS # E025 — no nested nondet blocks PASS # E026 — no self.* writes reachable from leader_fn PASS # E010 — all gl.nondet.* inside eq_principle block PASS # W001 — no forbidden imports PASS # W002 — no float(), no forbidden calls PASS # W004 — all raises use gl.vm.UserError PASS # W010 — dependency header on line 1 PASS # W020 — return type on all @gl.public.view methods PASS # ═══════════════════════════════════════════════════════════════════════════════ import hashlib import json from dataclasses import dataclass from datetime import datetime, timezone from genlayer import * # ══════════════════════════════════════════════════════════════════════════════ # Module-level pure helpers # # CRITICAL GenVM rule: leader_fn and any function it calls must have # ZERO self.* or storage references. Keeping helpers at module scope # makes this structurally impossible to violate — module-scope functions # cannot reference 'self' at all. # # Confirmed from sample contract (CopyGuard): _fetch_content, _build_prompt, # _safe_int are all module-level. This is the production-proven pattern. # ══════════════════════════════════════════════════════════════════════════════ def _sha256(value: str) -> str: """Deterministic SHA-256. Not in FORBIDDEN_MODULES or FORBIDDEN_CALLS.""" return hashlib.sha256(value.encode("utf-8")).hexdigest() def _compute_snapshot_hash( module_id: str, version: int, eval_prompt: str, criteria: str, score_tolerance: int, accept_threshold: int, min_confidence: int, max_dispute_rounds: int, challenge_window_sec: int, ) -> str: """ Canonical snapshot hash — identical algorithm as ModuleRegistry. Must match exactly: same field set, same order, same pipe separators. Called inside submit() to verify caller-supplied snapshot_hash. Pure function — no self, no storage, no nondet. """ canonical = ( module_id + "|" + str(version) + "|" + eval_prompt + "|" + criteria + "|" + str(score_tolerance) + "|" + str(accept_threshold) + "|" + str(min_confidence) + "|" + str(max_dispute_rounds) + "|" + str(challenge_window_sec) ) return _sha256(canonical) def _resolve_ref(ref: str, max_len: int) -> str: """ Fetch URL content or return inline string. Contains gl.nondet.web.render — ONLY call from inside leader_fn. Never call from deterministic context (E010 would fire). """ if ref.startswith("https://") or ref.startswith("http://"): try: return gl.nondet.web.render(ref, mode="text")[:max_len] except Exception: return "" return ref[:max_len] def _fill_prompt(template: str, output: str, context: str) -> str: """Slot-fill the evaluation prompt. Pure string operation.""" return template.replace("{output}", output).replace("{context}", context) def _safe_int(val: object, lo: int, hi: int) -> int: """Clamp-cast to int; returns lo on any conversion failure. No float().""" try: return max(lo, min(hi, int(val))) except Exception: return lo def _classify( score: int, confidence: int, accept_threshold: int, min_confidence: int, ) -> str: """ Confidence-first classification. Order of evaluation: 1. Low confidence → UNCERTAIN regardless of score. Prevents a confident-sounding VALID verdict when the LLM is guessing. 2. score >= accept_threshold → VALID 3. score in grey zone [accept_threshold-15, accept_threshold) → DISPUTED Signals borderline cases without forcing INVALID. 4. Otherwise → INVALID Pure function — deterministic, no nondet, no self. """ if confidence < min_confidence: return "UNCERTAIN" if score >= accept_threshold: return "VALID" if score >= (accept_threshold - 15): return "DISPUTED" return "INVALID" # ══════════════════════════════════════════════════════════════════════════════ # Protocol-level constants # ══════════════════════════════════════════════════════════════════════════════ MAX_OUTPUT_LEN: int = 8000 MAX_CONTEXT_LEN: int = 2000 MAX_METADATA_LEN: int = 256 MAX_FILLED_PROMPT_LEN: int = 10000 # hard cap on LLM input size (timeout guard) MIN_VALID_TIMESTAMP: int = 1704067200 # 2024-01-01T00:00:00Z sanity floor # Task status constants — form a one-way state machine: # PENDING → EVALUATED → FINALIZED (happy path) # EVALUATED → DISPUTED → EVALUATED (dispute cycle, max per module policy) STATUS_PENDING: str = "PENDING" STATUS_EVALUATED: str = "EVALUATED" STATUS_DISPUTED: str = "DISPUTED" STATUS_FINALIZED: str = "FINALIZED" # Classification output values (must match _classify() return strings) CLS_VALID: str = "VALID" CLS_INVALID: str = "INVALID" CLS_UNCERTAIN: str = "UNCERTAIN" CLS_DISPUTED: str = "DISPUTED" # ══════════════════════════════════════════════════════════════════════════════ # Storage dataclasses # All decorated @allow_storage @dataclass (E014). # All fields use SDK types: str, bool, u8, u32, u64, u256, Address (E015). # ══════════════════════════════════════════════════════════════════════════════ @allow_storage @dataclass class ModuleSnapshot: """ Immutable copy of module config captured at submit() time. Eliminates all cross-contract reads during evaluate(): - eval_prompt, criteria → used to build the LLM prompt - thresholds → used by _classify() and validator_fn tolerance checks - dispute policy fields → read by DisputeLedger from get_result() - snapshot_hash → proves this snapshot was not forged Phase II adds: snapshot_hash, max_dispute_rounds, challenge_window_sec, require_inline_content. These were previously absent or in constants. """ module_id: str module_type: str evaluation_method: str eval_prompt: str criteria: str score_tolerance: u8 accept_threshold: u8 min_confidence: u8 module_version: u32 snapshot_hash: str # Phase II: authenticity anchor max_dispute_rounds: u8 # Phase II: per-module dispute cap [1,3] challenge_window_sec: u32 # Phase II: per-module challenge window require_inline_content: bool # Phase II: content policy flag @allow_storage @dataclass class InputRecord: """ Submitted inputs plus SHA-256 hashes of the ref strings. output_hash / context_hash prove what was submitted (ref-level integrity). output_ref / context_ref are retained for re-fetching in re-evaluation. MVP note: hashes are of the ref strings themselves, not fetched content. Content-level hashing (fetch at submit time) is deferred to v2/Phase III. """ output_ref: str context_ref: str output_hash: str # SHA-256(output_ref) context_hash: str # SHA-256(context_ref) or "" if no context metadata: str @allow_storage @dataclass class EvalRecord: """ Single evaluation round result — stored in Task.eval_history. Provides a per-task audit trail across dispute rounds. Capacity in DynArray is max_dispute_rounds + 1 = 4. """ round_num: u8 score: u8 confidence: u8 classification: str eval_ts: u64 @allow_storage @dataclass class EvalResult: """ Current evaluation result stored in Task.result. Overwritten by each evaluate() call. History preserved in eval_history. """ score: u8 confidence: u8 classification: str reasoning: str # ≤ 500 chars from LLM eval_round: u8 @allow_storage @dataclass class Task: """ Complete task record. Created PENDING by submit(), updated by evaluate(), sealed FINALIZED by finalize(). """ task_id: str submitter: Address module: ModuleSnapshot input: InputRecord result: EvalResult status: str # STATUS_* constant created_ts: u64 last_eval_ts: u64 # Audit trail: history of all evaluation rounds (initial + up to 3 disputes) # Capacity 4 = 1 initial + PROTOCOL_MAX_DISPUTE_ROUNDS(3). # DynArray[T] syntax without N is used per SDK docs (GitHubProfilesRepositories example). eval_history: DynArray[EvalRecord] # ══════════════════════════════════════════════════════════════════════════════ # Contract # ══════════════════════════════════════════════════════════════════════════════ class VeritasCore(gl.Contract): # ── Primary storage ─────────────────────────────────────────────────────── tasks: TreeMap[str, Task] total_tasks: u256 # ── Secondary index: submitter → sequential index → task_id ────────────── # u256 key for inner TreeMap — matches CopyGuard production pattern. submitter_index: TreeMap[Address, TreeMap[u256, str]] submitter_counts: TreeMap[Address, u256] # ── Access control (Phase II) ───────────────────────────────────────────── deployer: Address # set in __init__ dispute_ledger_address: Address # set by configure() is_configured: bool # one-time lock; True after configure() def __init__(self) -> None: self.total_tasks = u256(0) self.deployer = gl.message.sender_address self.is_configured = False # ── Internal guards ─────────────────────────────────────────────────────── def _require(self, condition: bool, msg: str) -> None: """All error paths use gl.vm.UserError (W004 compliance).""" if not condition: raise gl.vm.UserError(msg) def _get_now(self) -> u64: """ Read transaction timestamp from GenVM runtime context. gl.message_raw["datetime"] — confirmed pattern from CopyGuard sample. Converts ISO-8601 string to UTC Unix timestamp. Rejects timestamps before MIN_VALID_TIMESTAMP sanity floor. Never uses time.time() or datetime.now() (W002 forbidden). """ try: raw: str = gl.message_raw["datetime"] dt = datetime.fromisoformat(raw.replace("Z", "+00:00")) if dt.tzinfo is None: dt = dt.replace(tzinfo=timezone.utc) ts = int(dt.timestamp()) if ts < MIN_VALID_TIMESTAMP: raise gl.vm.UserError("ERR:TIMESTAMP_BELOW_FLOOR") return u64(ts) except gl.vm.UserError: raise except Exception: raise gl.vm.UserError("ERR:TIMESTAMP_UNAVAILABLE") def _make_task_id(self, counter: u256, addr: Address) -> str: """ Deterministic task ID: VT-{08d counter}-{last 8 hex chars of address}. No uuid4() — pure deterministic construction. """ return f"VT-{int(counter):08d}-{addr.as_hex[-8:]}" # ── Internal: task construction ─────────────────────────────────────────── def _create_task( self, output_ref: str, context_ref: str, metadata: str, snapshot: ModuleSnapshot, now: u64, ) -> Task: """ Deterministic task construction. No LLM, no nondet, no cross-contract. Computes input hashes (ref-level integrity for MVP). Returns a Task in PENDING state with placeholder result. self.total_tasks must be incremented BEFORE calling this method. """ output_hash = _sha256(output_ref) context_hash = _sha256(context_ref) if context_ref else "" task_id = self._make_task_id(self.total_tasks, gl.message.sender_address) placeholder = EvalResult( score = u8(0), confidence = u8(0), classification = CLS_UNCERTAIN, reasoning = "", eval_round = u8(0), ) return Task( task_id = task_id, submitter = gl.message.sender_address, module = snapshot, input = InputRecord( output_ref = output_ref, context_ref = context_ref, output_hash = output_hash, context_hash = context_hash, metadata = metadata, ), result = placeholder, status = STATUS_PENDING, created_ts = u64(now), last_eval_ts = u64(0), eval_history = DynArray[EvalRecord]([]), ) # ── Internal: evaluation ────────────────────────────────────────────────── def _run_evaluation( self, output_ref: str, context_ref: str, eval_prompt: str, criteria: str, score_tolerance: int, accept_threshold: int, min_confidence: int, eval_round: int, ) -> EvalResult: """ Nondet isolation zone — the ONLY nondet-containing method. Pattern: gl.eq_principle.prompt_comparative(leader_fn, criteria_str) This is the production pattern used by CopyGuard (sample contract). leader_fn returns a JSON string (sort_keys=True for determinism). criteria_str instructs validators to compare numerically. ALL parameters captured as pure local primitives before leader_fn is defined. This is the critical E026 safety pattern: - leader_fn and _resolve_ref (which it calls) are reachable from the nondet entry point - Neither can reference self.* — module-scope functions have no self - Local captures (o_ref, c_ref, ep, etc.) are plain Python values The criteria string encodes the validator equivalence check: - |leader_score - validator_score| <= score_tolerance - |leader_confidence - validator_confidence| <= 20 - Both must reach the same classification tier This is NOT a second consensus layer. GenLayer's Optimistic Democracy IS the consensus. prompt_comparative makes validators independently run leader_fn and instructs them on when to agree (equivalence). """ # ── Capture all inputs as pure locals (E026 safety) ─────────────────── o_ref = output_ref c_ref = context_ref ep = eval_prompt tol = score_tolerance thresh = accept_threshold mconf = min_confidence rnd = eval_round o_max = MAX_OUTPUT_LEN c_max = MAX_CONTEXT_LEN p_max = MAX_FILLED_PROMPT_LEN # Round note appended for re-evaluations — increases analytical rigour round_note = ( f"\n\n[RE-EVALUATION ROUND {rnd}] " "Apply heightened scrutiny. " "Each dimension score must be justified with explicit textual evidence." if rnd > 0 else "" ) def leader_fn() -> str: """ Executed by the Leader validator. Calls module-level helpers only — zero self/storage references. _resolve_ref contains gl.nondet.web.render — safe here because leader_fn IS the nondet entry point for prompt_comparative. Returns JSON string with sort_keys=True for determinism. """ output = _resolve_ref(o_ref, o_max) context = _resolve_ref(c_ref, c_max) if c_ref else "" filled = _fill_prompt(ep, output, context) + round_note # Hard cap before LLM call — timeout mitigation filled = filled[:p_max] result = gl.nondet.exec_prompt(filled, response_format="json") # sort_keys=True ensures identical field ordering across LLM runs return json.dumps(result, sort_keys=True) # Criteria string instructs each validator on equivalence. # Validators independently run leader_fn and compare numerically. # Borderline-confidence tolerance: if both validators score confidence # within 10 points of min_confidence, accept a 15-point confidence # delta before forcing disagreement (reduces escalation-loop risk for # genuinely ambiguous outputs near the UNCERTAIN boundary). criteria_str = ( f"You are a validator comparing two independent AI evaluation results.\n" f"Both results are JSON strings containing: score, confidence, reasoning.\n" f"\n" f"The results are EQUIVALENT if ALL of the following hold:\n" f" 1. |score_A - score_B| <= {tol}\n" f" 2. |confidence_A - confidence_B| <= 20\n" f" 3. Both results map to the same classification tier:\n" f" VALID if confidence >= {mconf} AND score >= {thresh}\n" f" DISPUTED if confidence >= {mconf} AND {thresh - 15} <= score < {thresh}\n" f" INVALID if confidence >= {mconf} AND score < {thresh - 15}\n" f" UNCERTAIN if confidence < {mconf}\n" f" EXCEPTION: if both confidence values are within 10 of {mconf},\n" f" accept |confidence_A - confidence_B| <= 15 for the UNCERTAIN boundary.\n" f"\n" f"Respond ONLY with the single word 'true' if equivalent, 'false' if not.\n" f"No explanation. No punctuation. No other text.\n" f"Custom module criteria: {criteria}" ) raw = gl.eq_principle.prompt_comparative(leader_fn, criteria_str) # Parse the consensus result try: parsed = json.loads(raw) except Exception: raise gl.vm.UserError("ERR:EVAL_RESPONSE_NOT_JSON") if not isinstance(parsed, dict): raise gl.vm.UserError("ERR:EVAL_RESPONSE_NOT_DICT") if "score" not in parsed or "confidence" not in parsed: raise gl.vm.UserError("ERR:EVAL_RESPONSE_MISSING_FIELDS") score = _safe_int(parsed.get("score", 0), 0, 100) confidence = _safe_int(parsed.get("confidence", 0), 0, 100) reasoning = str(parsed.get("reasoning", ""))[:500] cls = _classify(score, confidence, thresh, mconf) return EvalResult( score = u8(score), confidence = u8(confidence), classification = cls, reasoning = reasoning, eval_round = u8(rnd), ) def _store_result( self, task_id: str, result: EvalResult, now: u64, ) -> None: """ Deterministic storage update. No LLM, no nondet. Appends to eval_history for audit trail. Transitions task status PENDING/DISPUTED → EVALUATED. """ task = self.tasks[task_id] # Append to history (audit trail) record = EvalRecord( round_num = u8(int(result.eval_round)), score = u8(int(result.score)), confidence = u8(int(result.confidence)), classification = result.classification, eval_ts = u64(now), ) task.eval_history.append(record) task.result = result task.status = STATUS_EVALUATED task.last_eval_ts = u64(now) self.tasks[task_id] = task # ── Write: configure ────────────────────────────────────────────────────── @gl.public.write def configure(self, dispute_ledger_addr: str) -> None: """ One-time post-deployment configuration. Deployer-only. Sets dispute_ledger_address — after which mark_disputed() is locked to that address only. Cannot be called twice (is_configured gate). Deployment sequence: ① Deploy ModuleRegistry → address A ② Deploy VeritasCore → address B (deployer set in __init__) ③ Deploy DisputeLedger → address D (core_address = B) ④ VeritasCore.configure(D) (locks configuration) Address format validation: 0x-prefixed 42-char hex string. This catches the most common operator mistake (wrong address). """ self._require(not self.is_configured, "ERR:ALREADY_CONFIGURED") self._require( gl.message.sender_address == self.deployer, "ERR:ONLY_DEPLOYER", ) self._require( len(dispute_ledger_addr) == 42 and dispute_ledger_addr.startswith("0x"), "ERR:INVALID_ADDRESS_FORMAT", ) self.dispute_ledger_address = Address(dispute_ledger_addr) self.is_configured = True # ── Write: submit ───────────────────────────────────────────────────────── @gl.public.write def submit( self, output_ref: str, context_ref: str, metadata: str, # Module snapshot fields — obtained by caller from ModuleRegistry.get_module() # VeritasCore recomputes snapshot_hash locally to verify; no cross-contract call. module_id: str, module_type: str, evaluation_method: str, eval_prompt: str, criteria: str, score_tolerance: int, accept_threshold: int, min_confidence: int, module_version: int, snapshot_hash: str, max_dispute_rounds: int, challenge_window_sec: int, require_inline_content: bool, ) -> str: """ Validate inputs, verify snapshot authenticity, store task in PENDING. Returns the new task_id. Does NOT evaluate — call evaluate(task_id) next. Snapshot authenticity verification (Vulnerability 1 fix): Caller reads ModuleRegistry.get_module(module_id) off-chain and passes all fields including snapshot_hash. submit() recomputes snapshot_hash locally from the submitted fields using the identical algorithm as ModuleRegistry. Any field alteration (including forged eval_prompt or doctored thresholds) produces a hash mismatch → revert. This eliminates the cross-contract call in the evaluation hot path while providing cryptographic binding between the submitted config and the stored task snapshot. """ # ── Input length validation ─────────────────────────────────────────── self._require( 0 < len(output_ref) <= MAX_OUTPUT_LEN, "ERR:OUTPUT_REF_EMPTY_OR_TOO_LONG", ) self._require( len(context_ref) <= MAX_CONTEXT_LEN, "ERR:CONTEXT_REF_TOO_LONG", ) self._require( len(metadata) <= MAX_METADATA_LEN, "ERR:METADATA_TOO_LONG", ) self._require(len(module_id) > 0, "ERR:MODULE_ID_EMPTY") self._require(module_version >= 1, "ERR:MODULE_VERSION_INVALID") # ── Content policy enforcement ──────────────────────────────────────── # require_inline_content blocks URL-based submissions for this module. # Protects high-integrity modules from mutable-content vulnerability. if require_inline_content: self._require( not output_ref.startswith("http://") and not output_ref.startswith("https://"), "ERR:INLINE_CONTENT_REQUIRED", ) # ── Snapshot hash self-verification ─────────────────────────────────── # Recompute using the same algorithm as ModuleRegistry._compute_snapshot_hash. # If any submitted field differs from what was registered, the hash # will not match and the transaction reverts. local_hash = _compute_snapshot_hash( module_id, module_version, eval_prompt, criteria, score_tolerance, accept_threshold, min_confidence, max_dispute_rounds, challenge_window_sec, ) self._require( local_hash == snapshot_hash, "ERR:SNAPSHOT_HASH_MISMATCH", ) # ── Structural prompt checks (belt-and-suspenders) ──────────────────── # ModuleRegistry already enforces these at registration. Rechecking # here ensures a caller cannot bypass by passing a deactivated module's # snapshot from a pre-delimiter-enforcement era. self._require("{output}" in eval_prompt, "ERR:PROMPT_MISSING_OUTPUT_SLOT") self._require("{context}" in eval_prompt, "ERR:PROMPT_MISSING_CONTEXT_SLOT") # ── Build module snapshot ───────────────────────────────────────────── snapshot = ModuleSnapshot( module_id = module_id, module_type = module_type, evaluation_method = evaluation_method, eval_prompt = eval_prompt, criteria = criteria, score_tolerance = u8(score_tolerance), accept_threshold = u8(accept_threshold), min_confidence = u8(min_confidence), module_version = u32(module_version), snapshot_hash = snapshot_hash, max_dispute_rounds = u8(max_dispute_rounds), challenge_window_sec = u32(challenge_window_sec), require_inline_content = require_inline_content, ) # ── Create and persist task ─────────────────────────────────────────── now = self._get_now() self.total_tasks = u256(int(self.total_tasks) + 1) task = self._create_task(output_ref, context_ref, metadata, snapshot, now) self.tasks[task.task_id] = task submitter = task.submitter if submitter not in self.submitter_counts: self.submitter_counts[submitter] = u256(0) idx = self.submitter_counts[submitter] self.submitter_index.get_or_insert_default(submitter)[idx] = task.task_id self.submitter_counts[submitter] = u256(int(idx) + 1) return task.task_id # ── Write: evaluate ─────────────────────────────────────────────────────── @gl.public.write def evaluate(self, task_id: str) -> None: """ Trigger LLM evaluation for a PENDING or DISPUTED task. Permissionless — anyone may call (enables stuck-state recovery). Uses the ModuleSnapshot frozen at submit() time — no cross-contract calls, no runtime registry dependency. Evaluation is fully self-contained. On success: task.status → EVALUATED, result stored, history appended. Stuck-state recovery: if mark_disputed() succeeds but evaluate() fails (e.g. gas exhaustion), task remains DISPUTED. Any caller can invoke evaluate() directly to complete the re-evaluation. """ self._require(task_id in self.tasks, "ERR:TASK_NOT_FOUND") task = self.tasks[task_id] self._require( task.status in (STATUS_PENDING, STATUS_DISPUTED), "ERR:TASK_NOT_EVALUABLE", ) now = self._get_now() mod = task.module eval_round = int(task.result.eval_round) result = self._run_evaluation( output_ref = task.input.output_ref, context_ref = task.input.context_ref, eval_prompt = mod.eval_prompt, criteria = mod.criteria, score_tolerance = int(mod.score_tolerance), accept_threshold = int(mod.accept_threshold), min_confidence = int(mod.min_confidence), eval_round = eval_round, ) self._store_result(task_id, result, now) # ── Write: finalize ─────────────────────────────────────────────────────── @gl.public.write def finalize(self, task_id: str) -> None: """ Permanently seal an EVALUATED task. Submitter-only (Requirement 7). After finalization: status = FINALIZED. No further disputes accepted. DisputeLedger checks task status before calling mark_disputed(). """ self._require(task_id in self.tasks, "ERR:TASK_NOT_FOUND") task = self.tasks[task_id] self._require( task.submitter == gl.message.sender_address, "ERR:NOT_TASK_SUBMITTER", ) self._require(task.status == STATUS_EVALUATED, "ERR:TASK_NOT_EVALUATED") task.status = STATUS_FINALIZED self.tasks[task_id] = task # ── Write: mark_disputed ────────────────────────────────────────────────── @gl.public.write def mark_disputed(self, task_id: str) -> None: """ Transition EVALUATED → DISPUTED. DisputeLedger-only (Vulnerability 2 fix). Access control: enforces dispute_ledger_address == msg.sender. This closes the critical unguarded access path from Phase I. Also increments result.eval_round so the next evaluate() call appends the strictness note and history round number correctly. Guards: - UNCERTAIN results cannot be disputed (already low confidence; re-evaluation is unlikely to resolve; forces external review) - FINALIZED tasks cannot be disputed Stuck-state: if this succeeds but evaluate() subsequently fails, task remains DISPUTED. evaluate() is permissionless — any caller can complete the re-evaluation. """ self._require(self.is_configured, "ERR:NOT_CONFIGURED") self._require( gl.message.sender_address == self.dispute_ledger_address, "ERR:ONLY_DISPUTE_LEDGER", ) self._require(task_id in self.tasks, "ERR:TASK_NOT_FOUND") task = self.tasks[task_id] self._require(task.status == STATUS_EVALUATED, "ERR:TASK_NOT_EVALUATED") self._require( task.result.classification != CLS_UNCERTAIN, "ERR:CANNOT_DISPUTE_UNCERTAIN", ) # Increment eval_round for the upcoming re-evaluation new_round = u8(int(task.result.eval_round) + 1) task.result.eval_round = new_round task.status = STATUS_DISPUTED self.tasks[task_id] = task # ── View methods ────────────────────────────────────────────────────────── @gl.public.view def get_task(self, task_id: str) -> dict: """ Full task record including module snapshot and input hashes. Includes eval_history for complete audit trail. """ self._require(task_id in self.tasks, "ERR:TASK_NOT_FOUND") t = self.tasks[task_id] history = [] for r in t.eval_history: history.append({ "round_num": int(r.round_num), "score": int(r.score), "confidence": int(r.confidence), "classification": r.classification, "eval_ts": int(r.eval_ts), }) return { "task_id": t.task_id, "submitter": t.submitter.as_hex, "status": t.status, "module_id": t.module.module_id, "module_type": t.module.module_type, "module_version": int(t.module.module_version), "snapshot_hash": t.module.snapshot_hash, "max_dispute_rounds": int(t.module.max_dispute_rounds), "challenge_window_sec": int(t.module.challenge_window_sec), "output_hash": t.input.output_hash, "context_hash": t.input.context_hash, "metadata": t.input.metadata, "score": int(t.result.score), "confidence": int(t.result.confidence), "classification": t.result.classification, "reasoning": t.result.reasoning, "eval_round": int(t.result.eval_round), "created_ts": int(t.created_ts), "last_eval_ts": int(t.last_eval_ts), "eval_history": history, } @gl.public.view def get_result(self, task_id: str) -> dict: """ Lightweight result view. Used by DisputeLedger eligibility checks. Includes dispute policy fields from snapshot so DisputeLedger does not need a second cross-contract call to read policy. """ self._require(task_id in self.tasks, "ERR:TASK_NOT_FOUND") t = self.tasks[task_id] return { "task_id": t.task_id, "submitter": t.submitter.as_hex, "status": t.status, "classification": t.result.classification, "score": int(t.result.score), "confidence": int(t.result.confidence), "eval_round": int(t.result.eval_round), "last_eval_ts": int(t.last_eval_ts), "max_dispute_rounds": int(t.module.max_dispute_rounds), "challenge_window_sec": int(t.module.challenge_window_sec), } @gl.public.view def task_exists(self, task_id: str) -> bool: """Lightweight existence check.""" return task_id in self.tasks @gl.public.view def get_tasks_by_submitter(self, submitter_hex: str, offset: int, limit: int) -> list: """ Paginated task ID list for a submitter address. offset: 0-based start index. limit: capped at 50. Returns empty list for unknown submitters or out-of-range offsets. """ addr = Address(submitter_hex) total = int(self.submitter_counts.get(addr, u256(0))) if offset >= total or limit <= 0: return [] capped = min(limit, 50) end = min(offset + capped, total) result = [] for i in range(offset, end): result.append(self.submitter_index[addr][u256(i)]) return result @gl.public.view def get_total_tasks(self) -> int: """Total submitted tasks across all modules.""" return int(self.total_tasks) @gl.public.view def get_protocol_info(self) -> dict: """Protocol configuration for dashboards and consumers.""" return { "total_tasks": int(self.total_tasks), "is_configured": self.is_configured, "dispute_ledger": self.dispute_ledger_address.as_hex if self.is_configured else "", "max_output_len": MAX_OUTPUT_LEN, "max_context_len": MAX_CONTEXT_LEN, "max_filled_prompt": MAX_FILLED_PROMPT_LEN, }