# v0.3.0 # { "Depends": "py-genlayer:5jycge4q8k23462jtb0b9fyey1s9qz928sz2nbrd9mg4sxqg2qng" } import json import genlayer as gl from genlayer.types import * VERSION = "1.0.0" VERDICTS = ("accepted", "rejected", "inconclusive") MAX_TITLE, MIN_CRIT, MAX_CRIT, MAX_URL = 120, 20, 800, 300 MIN_WINDOW, MAX_WINDOW = 60, 30 * 24 * 3600 # seconds DEFAULT_REVIEW, DEFAULT_DISPUTE = 3 * 24 * 3600, 24 * 3600 # used when the deploy form is left at 0 _K = [ 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967, 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2, ] def _norm(text: str) -> str: return " ".join(text.lower().split()) def _ror(x: int, n: int) -> int: return ((x >> n) | (x << (32 - n))) & 0xFFFFFFFF def _sha256_hex(text: str) -> str: """Pure-Python SHA-256 so the contract does not depend on any extra stdlib module.""" data = text.encode("utf-8") h = [0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19] bits = len(data) * 8 data += b"\x80" data += b"\x00" * ((56 - len(data) % 64) % 64) data += bits.to_bytes(8, "big") for i in range(0, len(data), 64): w = [int.from_bytes(data[i + j * 4: i + j * 4 + 4], "big") for j in range(16)] for j in range(16, 64): s0 = _ror(w[j - 15], 7) ^ _ror(w[j - 15], 18) ^ (w[j - 15] >> 3) s1 = _ror(w[j - 2], 17) ^ _ror(w[j - 2], 19) ^ (w[j - 2] >> 10) w.append((w[j - 16] + s0 + w[j - 7] + s1) & 0xFFFFFFFF) a, b, c, d, e, f, g, k = h for j in range(64): t1 = (k + (_ror(e, 6) ^ _ror(e, 11) ^ _ror(e, 25)) + ((e & f) ^ ((~e) & g)) + _K[j] + w[j]) & 0xFFFFFFFF t2 = ((_ror(a, 2) ^ _ror(a, 13) ^ _ror(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) & 0xFFFFFFFF k, g, f, e, d, c, b, a = g, f, e, (d + t1) & 0xFFFFFFFF, c, b, a, (t1 + t2) & 0xFFFFFFFF h = [(x + y) & 0xFFFFFFFF for x, y in zip(h, [a, b, c, d, e, f, g, k])] return "".join(f"{x:08x}" for x in h) def _unix(iso: str) -> int: """'2026-09-27T09:14:14.081651Z' -> unix seconds, integer math only (datetime is forbidden in contracts).""" y, mo, d = int(iso[0:4]), int(iso[5:7]), int(iso[8:10]) hh, mi, ss = int(iso[11:13]), int(iso[14:16]), int(iso[17:19]) y -= 1 if mo <= 2 else 0 era = y // 400 yoe = y - era * 400 doy = (153 * ((mo + 9) % 12) + 2) // 5 + d - 1 doe = yoe * 365 + yoe // 4 - yoe // 100 + doy return (era * 146097 + doe - 719468) * 86400 + hh * 3600 + mi * 60 + ss def _now() -> int: """Transaction time from the consensus-agreed message; 0 if the runtime does not provide it.""" try: return _unix(gl.message_raw["datetime"]) except Exception: return 0 def _parse_verdict(raw: str) -> str: """Strict parsing: JSON {"verdict": ...} or exactly one bare word. Anything else is inconclusive.""" cleaned = raw.replace("```json", "").replace("```", "").strip() word = cleaned.lower().strip(" \n\t\"'.") try: obj = json.loads(cleaned) if isinstance(obj, dict): word = str(obj.get("verdict", "")).strip().lower() except Exception: pass return word if word in VERDICTS else "inconclusive" @gl.evm.contract_interface class _Recipient: class View: pass class Write: pass class Handoff(gl.contract.Contract): jobs: gl.storage.TreeMap[u256, str] # job id -> JSON record credits: gl.storage.TreeMap[Address, u256] # withdrawable balances next_id: u256 review_window: u256 # seconds the client has to approve or dispute before the freelancer can claim payment dispute_timeout: u256 # seconds a dispute may stay unresolved before anyone can split the escrow def __init__(self, review_window_seconds: int = 0, dispute_timeout_seconds: int = 0): if review_window_seconds == 0: review_window_seconds = DEFAULT_REVIEW if dispute_timeout_seconds == 0: dispute_timeout_seconds = DEFAULT_DISPUTE for v in (review_window_seconds, dispute_timeout_seconds): if v < MIN_WINDOW or v > MAX_WINDOW: raise gl.vm.UserError("windows must be between 60 seconds and 30 days") self.next_id = 0 self.review_window = review_window_seconds self.dispute_timeout = dispute_timeout_seconds # ---------- write ---------- @gl.public.write.payable def create_job(self, title: str, criteria: str, freelancer: str) -> None: """Client locks the payment in escrow and writes the acceptance criteria.""" amount = gl.message.value title, criteria = title.strip(), criteria.strip() if amount == 0: raise gl.vm.UserError("send the payment amount") if not title or len(title) > MAX_TITLE: raise gl.vm.UserError("title must be 1-120 characters") if len(criteria) < MIN_CRIT or len(criteria) > MAX_CRIT: raise gl.vm.UserError("acceptance criteria must be 20-800 characters") try: freelancer_hex = Address(freelancer.strip()).as_hex except Exception: raise gl.vm.UserError("freelancer must be a valid wallet address") client_hex = gl.message.sender_address.as_hex if freelancer_hex == client_hex: raise gl.vm.UserError("the freelancer must be a different account") record = { "client": client_hex, "freelancer": freelancer_hex, "title": title, "criteria": criteria, "criteria_hash": _sha256_hex(_norm(criteria)), "amount": int(amount), "status": "funded", # funded|submitted|disputed|paid|auto_paid|refunded|cancelled|accepted|rejected|inconclusive|expired "url": "", "created_at": _now(), "submitted_at": 0, "disputed_at": 0, "evidence_excerpt": "", "evidence_hash": "", "evidence_note": "", } self.jobs[self.next_id] = json.dumps(record) self.next_id = self.next_id + 1 @gl.public.write def cancel_job(self, job_id: int) -> None: """Escrow recovery 1: the client takes the payment back before any work is submitted.""" rec = self._load(job_id) self._only(rec, "client") if rec["status"] != "funded": raise gl.vm.UserError("work was already submitted") self._credit(Address(rec["client"]), rec["amount"]) rec["status"] = "cancelled" self._save(job_id, rec) @gl.public.write def submit_work(self, job_id: int, url: str) -> None: """Freelancer submits a public https link; validators capture the page as evidence NOW.""" rec = self._load(job_id) self._only(rec, "freelancer") if rec["status"] != "funded": raise gl.vm.UserError("job is not waiting for work") url = url.strip() if not url.startswith("https://") or len(url) > MAX_URL or " " in url: raise gl.vm.UserError("url must be an https:// link without spaces") def capture() -> str: def out(ok: bool, excerpt: str, note: str) -> str: return json.dumps({"ok": ok, "excerpt": excerpt, "note": note}, sort_keys=True) try: page = gl.nondet.web.render(url, mode="text") except Exception: return out(False, "", "submitted page could not be read") text = _norm(page) if len(text) < 50: return out(False, "", "submitted page has too little readable text") return out(True, text[:2000], "captured at submission") snap = json.loads(gl.eq_principle.strict_eq(capture)) if not snap["ok"]: raise gl.vm.UserError(snap["note"]) # reverts, nothing changes rec["url"] = url rec["submitted_at"] = _now() rec["evidence_excerpt"] = snap["excerpt"] # authoritative evidence, immune to later edits of the page rec["evidence_hash"] = _sha256_hex(snap["excerpt"]) rec["evidence_note"] = snap["note"] rec["status"] = "submitted" self._save(job_id, rec) @gl.public.write def approve(self, job_id: int) -> None: """Client accepts the work: the freelancer is paid.""" rec = self._load(job_id) self._only(rec, "client") if rec["status"] != "submitted": raise gl.vm.UserError("no submitted work to approve") self._credit(Address(rec["freelancer"]), rec["amount"]) rec["status"] = "paid" self._save(job_id, rec) @gl.public.write def dispute(self, job_id: int) -> None: """Client rejects the work: validators will judge it against the criteria.""" rec = self._load(job_id) self._only(rec, "client") if rec["status"] != "submitted": raise gl.vm.UserError("no submitted work to dispute") rec["status"] = "disputed" rec["disputed_at"] = _now() self._save(job_id, rec) @gl.public.write def concede(self, job_id: int) -> None: """Freelancer gives up: the client is refunded.""" rec = self._load(job_id) self._only(rec, "freelancer") if rec["status"] not in ("submitted", "disputed"): raise gl.vm.UserError("nothing to concede") self._credit(Address(rec["client"]), rec["amount"]) rec["status"] = "refunded" self._save(job_id, rec) @gl.public.write def claim_after_review(self, job_id: int) -> None: """Escrow recovery 2 (timeout): a silent client cannot hold the freelancer's payment forever.""" rec = self._load(job_id) self._only(rec, "freelancer") if rec["status"] != "submitted": raise gl.vm.UserError("work is not waiting for review") now = _now() if rec["submitted_at"] <= 0 or now <= 0 or now < rec["submitted_at"] + self.review_window: raise gl.vm.UserError("review window has not ended") self._credit(Address(rec["freelancer"]), rec["amount"]) rec["status"] = "auto_paid" self._save(job_id, rec) @gl.public.write def claim_expired_dispute(self, job_id: int) -> None: """Escrow recovery 3 (timeout): an unresolved dispute splits the escrow 50/50.""" rec = self._load(job_id) if rec["status"] != "disputed": raise gl.vm.UserError("job is not disputed") now = _now() if rec["disputed_at"] <= 0 or now <= 0 or now < rec["disputed_at"] + self.dispute_timeout: raise gl.vm.UserError("dispute timeout has not been reached") self._split(rec) rec["status"] = "expired" self._save(job_id, rec) @gl.public.write def resolve(self, job_id: int) -> str: """Validators judge the evidence snapshot against the acceptance criteria.""" rec = self._load(job_id) if rec["status"] != "disputed": raise gl.vm.UserError("job is not disputed") # copy to locals: storage can't be read inside the non-deterministic block title, criteria, excerpt = rec["title"], rec["criteria"], rec["evidence_excerpt"] def judge() -> str: task = f""" A freelancer delivered work for the job "{title}". Acceptance criteria written by the client: {criteria} This is the beginning of the delivered page, captured at submission (normalized, lowercase): {excerpt} End of page excerpt. Does the delivered work satisfy the acceptance criteria? "accepted" if it clearly does, "rejected" if it clearly does not, "inconclusive" if the excerpt is not enough to tell. Respond only with JSON: {{"verdict": "accepted" | "rejected" | "inconclusive"}} """ try: verdict = _parse_verdict(gl.nondet.exec_prompt(task)) except Exception: verdict = "inconclusive" return json.dumps({"verdict": verdict}, sort_keys=True) verdict = json.loads(gl.eq_principle.strict_eq(judge))["verdict"] if verdict not in VERDICTS: verdict = "inconclusive" if verdict == "accepted": self._credit(Address(rec["freelancer"]), rec["amount"]) elif verdict == "rejected": self._credit(Address(rec["client"]), rec["amount"]) else: self._split(rec) rec["status"] = verdict rec["evidence_note"] = "judged on the snapshot captured at submission" self._save(job_id, rec) return verdict @gl.public.write def withdraw(self) -> None: """Pull payment: credits are zeroed before the transfer is emitted.""" me = gl.message.sender_address amount = self.credits.get(me, 0) if amount == 0: raise gl.vm.UserError("nothing to withdraw") self.credits[me] = 0 _Recipient(me).emit_transfer(value=amount) # ---------- view ---------- @gl.public.view def get_job(self, job_id: int) -> str: if job_id < 0 or job_id >= self.next_id: raise gl.vm.UserError("unknown job") return self.jobs[job_id] # JSON string; the frontend parses it @gl.public.view def get_job_count(self) -> int: return self.next_id @gl.public.view def get_credit(self, account: str) -> str: return str(self.credits.get(Address(account), 0)) @gl.public.view def get_config(self) -> str: return json.dumps({"version": VERSION, "review_window_seconds": int(self.review_window), "dispute_timeout_seconds": int(self.dispute_timeout)}) @gl.public.view def get_version(self) -> str: return VERSION # ---------- internal ---------- def _load(self, job_id: int) -> dict: if job_id < 0 or job_id >= self.next_id: raise gl.vm.UserError("unknown job") return json.loads(self.jobs[job_id]) def _save(self, job_id: int, rec: dict) -> None: self.jobs[job_id] = json.dumps(rec) def _only(self, rec: dict, role: str) -> None: if gl.message.sender_address.as_hex != rec[role]: raise gl.vm.UserError(f"only the {role} can do this") def _credit(self, who: Address, amount: int) -> None: self.credits[who] = self.credits.get(who, 0) + amount def _split(self, rec: dict) -> None: half = rec["amount"] // 2 self._credit(Address(rec["client"]), half) self._credit(Address(rec["freelancer"]), rec["amount"] - half)