# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } """ PatchLock – Causal Fix-Verification Bounty ========================================== A funder locks GEN on a frozen original program, a narrow bug claim, and a narrow required behavior. A solver submits a patched program. GenVM validators independently decide three booleans: bug_exists – the cited failure is present in the original fix_removes_bug – that failure is gone after the patch happy_path_preserved – the funder's required behavior still holds The bounty pays iff ALL THREE are True. Otherwise the attempt is rejected. After the deadline the funder can permissionlessly reclaim their GEN. Design primitives: - Causal property-flip (unique; not a static-audit, jailbreak, or split) - Deterministic pre-LLM gates that REVERT; never enter consensus - json.loads-only JSON parsing; no regex over blobs - Single stored verdict blob; get_bounty derives everything from it - recompute_settlement() always equals get_bounty()["settlement"] - Payout via gl.get_contract_at(recipient).emit_transfer() to an Address - No unbounded arrays (stores only attempt_count + last scalar fields) - Explicit deadline → expire → refund; funds cannot strand """ from genlayer import * import json from dataclasses import dataclass # ─── Constants ──────────────────────────────────────────────────────────────── MAX_ATTEMPTS: int = 3 # Size caps (chars, not bytes – GenVM uses str length) CODE_MIN: int = 1 CODE_MAX: int = 8_000 CLAIM_MIN: int = 1 CLAIM_MAX: int = 500 EXCERPT_MIN: int = 20 EXCERPT_MAX: int = 280 # Settlement tokens – stored as str, never as enum (GenLayer storage rule) SOLVER_PAID: str = "SOLVER_PAID" NO_PAY: str = "NO_PAY" FUNDER_REFUND: str = "FUNDER_REFUND" # State tokens S_OPEN: str = "OPEN" S_JUDGING: str = "JUDGING" S_ACCEPTED: str = "ACCEPTED" S_REJECTED: str = "REJECTED" S_EXPIRED: str = "EXPIRED" # ─── Dataclass ──────────────────────────────────────────────────────────────── @allow_storage @dataclass class BountyRecord: # Frozen inputs funder: Address recipient: Address # wallet that receives payout; equals solver unless declared original_code: str bug_claim: str required_behavior: str failing_excerpt: str failing_lines: str # comma-separated 1-indexed line numbers inside failing_excerpt deadline: u256 # UNIX timestamp (seconds) amount: u256 # wei locked # Mutable state (scalars only – no unbounded arrays) state: str # one of S_* attempt_count: u256 # Last-attempt verdict (scalars – single source of truth) last_bug_exists: bool last_fix_removes_bug: bool last_happy_path_preserved: bool last_settlement: str # one of SOLVER_PAID | NO_PAY | FUNDER_REFUND consensus_ran: bool # Last-attempt audit trail (scalars) last_fix_excerpt: str last_behavior_excerpt: str last_reason: str # ─── Contract ───────────────────────────────────────────────────────────────── class PatchLock(gl.Contract): # Storage: keyed map of bounties; monotonically-incrementing counter bounties: TreeMap[u256, BountyRecord] next_id: u256 def __init__(self) -> None: self.next_id = u256(0) # ── Public write methods ────────────────────────────────────────────────── @gl.public.write.payable def create_bounty( self, original_code: str, bug_claim: str, required_behavior: str, failing_excerpt: str, failing_lines: str, deadline: u256, recipient: Address, ) -> u256: """ Lock GEN and open a new bounty. Returns the bounty_id. Recipient is the wallet that receives the payout on FIX_ACCEPTED. Funder is gl.message.sender_address. Funds come from gl.message.value (must be > 0). """ amount = gl.message.value if amount == u256(0): raise gl.vm.UserError("Must attach GEN to fund the bounty") # Deterministic gates – all revert before any LLM call _check_code(original_code, "original_code") _check_claim(bug_claim, "bug_claim") _check_claim(required_behavior, "required_behavior") _check_excerpt(failing_excerpt, "failing_excerpt") _validate_lines(failing_lines, failing_excerpt, "failing_lines/failing_excerpt") if failing_excerpt not in original_code: raise gl.vm.UserError("failing_excerpt not found in original_code") bounty_id = self.next_id self.next_id = self.next_id + u256(1) self.bounties[bounty_id] = BountyRecord( funder=gl.message.sender_address, recipient=recipient, original_code=original_code, bug_claim=bug_claim, required_behavior=required_behavior, failing_excerpt=failing_excerpt, failing_lines=failing_lines, deadline=deadline, amount=amount, state=S_OPEN, attempt_count=u256(0), last_bug_exists=False, last_fix_removes_bug=False, last_happy_path_preserved=False, last_settlement=NO_PAY, consensus_ran=False, last_fix_excerpt="", last_behavior_excerpt="", last_reason="", ) return bounty_id @gl.public.write def attempt_fix( self, bounty_id: u256, patched_code: str, fix_excerpt: str, fix_lines: str, behavior_excerpt: str, behavior_lines: str, ) -> None: """ Solver submits a patch. Runs deterministic gates, then the three- boolean judge via run_nondet_unsafe. On acceptance, pays recipient. On rejection, consumes one attempt slot; bounty stays OPEN if slots remain. """ if bounty_id not in self.bounties: raise gl.vm.UserError("Unknown bounty_id") b = self.bounties[bounty_id] # State gate if b.state not in (S_OPEN, S_REJECTED): raise gl.vm.UserError("Bounty not open for attempts") # Attempt cap if b.attempt_count >= u256(MAX_ATTEMPTS): raise gl.vm.UserError("Maximum attempts reached") # In-flight guard (no stacking while JUDGING) if b.state == S_JUDGING: raise gl.vm.UserError("A judge is already in progress") # ── Deterministic pre-LLM gates ────────────────────────────────────── _check_code(patched_code, "patched_code") _check_excerpt(fix_excerpt, "fix_excerpt") _check_excerpt(behavior_excerpt, "behavior_excerpt") _validate_lines(fix_lines, fix_excerpt, "fix_lines/fix_excerpt") _validate_lines(behavior_lines, behavior_excerpt, "behavior_lines/behavior_excerpt") # patched_code must differ if patched_code == b.original_code: raise gl.vm.UserError("patched_code is identical to original_code") # fix_excerpt must be in patched_code if fix_excerpt not in patched_code: raise gl.vm.UserError("fix_excerpt not found in patched_code") # behavior_excerpt must be in patched_code if behavior_excerpt not in patched_code: raise gl.vm.UserError("behavior_excerpt not found in patched_code") # DELTA CITATION GATE (load-bearing): fix_excerpt must NOT be in original_code. # A solver who cites text that already existed has not proven an edit. if fix_excerpt in b.original_code: raise gl.vm.UserError( "fix_excerpt already exists in original_code – delta not proven" ) # ── Transition to JUDGING ───────────────────────────────────────────── b.state = S_JUDGING b.attempt_count = b.attempt_count + u256(1) self.bounties[bounty_id] = b # ── Non-deterministic judge ─────────────────────────────────────────── # Capture locals for closures (GenVM requires explicit capture) orig = b.original_code patch = patched_code claim = b.bug_claim behav = b.required_behavior f_exc = b.failing_excerpt fx_exc = fix_excerpt bx_exc = behavior_excerpt def _build_prompt() -> str: return ( "You are a precise code auditor. Answer ONLY with valid JSON, " "nothing else.\n\n" "=== ORIGINAL CODE ===\n" + orig + "\n\n" "=== PATCHED CODE ===\n" + patch + "\n\n" "=== BUG CLAIM (yes/no question) ===\n" + claim + "\n\n" "=== REQUIRED BEHAVIOR (yes/no question) ===\n" + behav + "\n\n" "=== FAILING EXCERPT (from original) ===\n" + f_exc + "\n\n" "=== FIX EXCERPT (from patched) ===\n" + fx_exc + "\n\n" "=== BEHAVIOR EXCERPT (from patched) ===\n" + bx_exc + "\n\n" "Return exactly this JSON object with no extra keys:\n" "{\n" ' "bug_exists": ,\n' ' "fix_removes_bug": ,\n' ' "happy_path_preserved": ,\n' ' "reason": ""\n' "}\n" "bug_exists: Is the bug claim factually true of the ORIGINAL code?\n" "fix_removes_bug: Does the PATCHED code no longer exhibit the cited failure?\n" "happy_path_preserved: Does the PATCHED code satisfy the required behavior?\n" ) def leader_fn(): raw = gl.nondet.exec_prompt(_build_prompt(), response_format="json") return _parse_verdict(raw) def validator_fn(leader_result: gl.vm.Result) -> bool: if not isinstance(leader_result, gl.vm.Return): return False lv = leader_result.calldata # lv must be a dict with exactly the four top-level keys if not isinstance(lv, dict): return False expected_keys = {"bug_exists", "fix_removes_bug", "happy_path_preserved", "reason"} if set(lv.keys()) != expected_keys: return False if not isinstance(lv["bug_exists"], bool): return False if not isinstance(lv["fix_removes_bug"], bool): return False if not isinstance(lv["happy_path_preserved"], bool): return False # Re-run the same judge independently from scratch raw = gl.nondet.exec_prompt(_build_prompt(), response_format="json") my_verdict = _parse_verdict(raw) # Accept iff ALL THREE booleans match exactly (no tolerance band) return ( my_verdict["bug_exists"] == lv["bug_exists"] and my_verdict["fix_removes_bug"] == lv["fix_removes_bug"] and my_verdict["happy_path_preserved"] == lv["happy_path_preserved"] ) verdict = gl.vm.run_nondet_unsafe(leader_fn, validator_fn) # ── Settle ─────────────────────────────────────────────────────────── bug = verdict.get("bug_exists", False) fix = verdict.get("fix_removes_bug", False) happy = verdict.get("happy_path_preserved", False) reason = str(verdict.get("reason", "")) accepted = _derive_accepted(bug, fix, happy) # Reload (storage may have been re-read) b = self.bounties[bounty_id] b.last_bug_exists = bug b.last_fix_removes_bug = fix b.last_happy_path_preserved = happy b.last_reason = reason b.consensus_ran = True b.last_fix_excerpt = fix_excerpt b.last_behavior_excerpt = behavior_excerpt if accepted: b.state = S_ACCEPTED b.last_settlement = SOLVER_PAID self.bounties[bounty_id] = b # Pay out recipient (must be an Address) other = gl.get_contract_at(b.recipient) other.emit_transfer(value=b.amount, on="accepted") else: # Attempts may remain – go back to OPEN, not REJECTED if b.attempt_count < u256(MAX_ATTEMPTS): b.state = S_OPEN else: b.state = S_REJECTED b.last_settlement = NO_PAY self.bounties[bounty_id] = b @gl.public.write def expire_bounty(self, bounty_id: u256) -> None: """ Permissionless expiry after deadline. Refunds the funder. Consensus never runs on expiry. Deadline is stored as UNIX timestamp (seconds). Current time is read from gl.message_raw['datetime'] (ISO-8601 string). """ if bounty_id not in self.bounties: raise gl.vm.UserError("Unknown bounty_id") b = self.bounties[bounty_id] if b.state not in (S_OPEN, S_REJECTED): raise gl.vm.UserError("Bounty is not in an expirable state") # Parse current block time (supports datetime.now() in direct mode / WASI) current_ts = _get_current_timestamp() if current_ts < int(b.deadline): raise gl.vm.UserError("Deadline has not been reached yet") b.state = S_EXPIRED b.last_settlement = FUNDER_REFUND b.consensus_ran = False self.bounties[bounty_id] = b # Refund funder other = gl.get_contract_at(b.funder) other.emit_transfer(value=b.amount, on="accepted") # ── Public view methods ─────────────────────────────────────────────────── @gl.public.view def get_bounty(self, bounty_id: u256) -> dict: """ Return a complete snapshot. ALL derived fields come from the single stored verdict blob – there is no duplicate status that could disagree. """ if bounty_id not in self.bounties: raise gl.vm.UserError("Unknown bounty_id") b = self.bounties[bounty_id] # Derive settlement from booleans (single source of truth) settlement = _recompute(b) return { "bounty_id": int(bounty_id), "state": b.state, "settlement": settlement, "consensus_ran": b.consensus_ran, "funder": str(b.funder), "recipient": str(b.recipient), "amount": int(b.amount), "deadline": int(b.deadline), "attempt_count": int(b.attempt_count), # Verdict booleans (audit) "bug_exists": b.last_bug_exists, "fix_removes_bug": b.last_fix_removes_bug, "happy_path_preserved": b.last_happy_path_preserved, "reason": b.last_reason, # Excerpt citations (audit) "last_fix_excerpt": b.last_fix_excerpt, "last_behavior_excerpt": b.last_behavior_excerpt, } @gl.public.view def recompute_settlement(self, bounty_id: u256) -> str: """ Pure function. Must always equal get_bounty(bounty_id)["settlement"]. """ if bounty_id not in self.bounties: raise gl.vm.UserError("Unknown bounty_id") b = self.bounties[bounty_id] return _recompute(b) # ─── Pure helpers (no storage access) ───────────────────────────────────────── def _derive_accepted(bug: bool, fix: bool, happy: bool) -> bool: """Single source of truth: all three must be True.""" return bug and fix and happy def _recompute(b: BountyRecord) -> str: """Derives settlement string from the stored verdict blob.""" if b.state == S_EXPIRED: return FUNDER_REFUND if _derive_accepted(b.last_bug_exists, b.last_fix_removes_bug, b.last_happy_path_preserved): return SOLVER_PAID return NO_PAY def _parse_verdict(raw) -> dict: """ Parse LLM JSON response. Uses json.loads on top-level keys only. No regex. Returns a safe dict with correct types regardless of LLM quirks. If the object is malformed, missing keys, or has non-bool values for the three boolean fields, we return all-False (FIX_REJECTED) rather than crashing the VM or trapping funds. Nested keys with the same names are IGNORED – only top-level is read. """ # raw may already be a dict (exec_prompt with response_format="json") if isinstance(raw, dict): parsed = raw else: try: parsed = json.loads(str(raw)) except Exception: return {"bug_exists": False, "fix_removes_bug": False, "happy_path_preserved": False, "reason": "parse_error"} if not isinstance(parsed, dict): return {"bug_exists": False, "fix_removes_bug": False, "happy_path_preserved": False, "reason": "not_a_dict"} # Read ONLY top-level keys – nested dicts are NOT inspected for booleans bug = parsed.get("bug_exists") fix = parsed.get("fix_removes_bug") happy = parsed.get("happy_path_preserved") reason = str(parsed.get("reason", "")) # Coerce: LLMs sometimes return "true"/"false" strings def _to_bool(v) -> bool: if isinstance(v, bool): return v if isinstance(v, str): return v.lower() == "true" return False # If any required boolean key is missing entirely, reject if ("bug_exists" not in parsed or "fix_removes_bug" not in parsed or "happy_path_preserved" not in parsed): return {"bug_exists": False, "fix_removes_bug": False, "happy_path_preserved": False, "reason": "missing_keys"} return { "bug_exists": _to_bool(bug), "fix_removes_bug": _to_bool(fix), "happy_path_preserved": _to_bool(happy), "reason": reason, } def _get_current_timestamp() -> int: """ Get the current block timestamp as an integer. Uses datetime.datetime.now(timezone.utc) (which gltest direct-mode patches on vm.warp()) and falls back to gl.message_raw['datetime']. """ import datetime as _dt try: now = _dt.datetime.now(_dt.timezone.utc) return int(now.timestamp()) except Exception: pass try: if hasattr(gl, "message_raw") and gl.message_raw and "datetime" in gl.message_raw: return _parse_datetime_to_unix(gl.message_raw["datetime"]) except Exception: pass return 0 def _parse_datetime_to_unix(dt_str: str) -> int: """ Convert an ISO-8601 datetime string (from gl.message_raw['datetime']) to a UNIX timestamp integer. GenLayer provides the datetime in UTC. Accepts formats: '2024-06-01T12:00:00Z' or '2024-06-01T12:00:00+00:00' Uses only the datetime stdlib module – no forbidden imports. """ import datetime as _dt # Normalize 'Z' suffix → '+00:00' for Python 3.11 fromisoformat normalized = dt_str.rstrip("Z") if not normalized.endswith("+00:00") and "+" not in normalized and "-" not in normalized[10:]: normalized += "+00:00" else: normalized = dt_str.replace("Z", "+00:00") d = _dt.datetime.fromisoformat(normalized) return int(d.timestamp()) # ─── Validation helpers ──────────────────────────────────────────────────────── def _check_code(code: str, name: str) -> None: if not isinstance(code, str) or len(code) < CODE_MIN or len(code) > CODE_MAX: raise gl.vm.UserError( f"{name} length must be {CODE_MIN}–{CODE_MAX} chars" ) def _check_claim(text: str, name: str) -> None: if not isinstance(text, str) or len(text) < CLAIM_MIN or len(text) > CLAIM_MAX: raise gl.vm.UserError( f"{name} length must be {CLAIM_MIN}–{CLAIM_MAX} chars" ) def _check_excerpt(text: str, name: str) -> None: if not isinstance(text, str) or len(text) < EXCERPT_MIN or len(text) > EXCERPT_MAX: raise gl.vm.UserError( f"{name} length must be {EXCERPT_MIN}–{EXCERPT_MAX} chars" ) def _validate_lines(line_str: str, excerpt: str, name: str) -> None: """ Every cited line number must exist in the excerpt (1-indexed). line_str is a comma-separated list of integers, e.g. "1,2,5". """ if not line_str.strip(): raise gl.vm.UserError(f"{name}: line_str must not be empty") excerpt_lines = excerpt.split("\n") n = len(excerpt_lines) try: cited = [int(x.strip()) for x in line_str.split(",") if x.strip()] except ValueError: raise gl.vm.UserError(f"{name}: line numbers must be integers") if not cited: raise gl.vm.UserError(f"{name}: at least one line number required") for ln in cited: if ln < 1 or ln > n: raise gl.vm.UserError( f"{name}: line {ln} out of range 1–{n}" )