# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } import json import re from dataclasses import dataclass from genlayer import * ERROR_EXPECTED = "[EXPECTED]" ERROR_LLM = "[LLM_ERROR]" @allow_storage @dataclass class Obligation: obligation_id: str description: str responsible_party: str deadline: str rule_type: str # "NUMERIC", "DEADLINE", "SEMANTIC" target_value: str comparison_op: str # ">=", "<=", "==", "<", ">", "EVAL" is_mandatory: bool @allow_storage @dataclass class Evidence: evidence_id: str submitted_by: str description: str source_reference: str content: str @allow_storage @dataclass class ObligationResult: obligation_id: str status: str # "FULFILLED", "NOT_FULFILLED", "INSUFFICIENT_EVIDENCE" evidence_sufficient: bool rule_type: str observed_fact: str target_value: str comparison_op: str explanation: str @allow_storage @dataclass class Agreement: agreement_id: str creator: Address debtor: Address creditor: Address escrow_amount: u256 escrow_status: str # "NONE", "UNFUNDED", "FUNDED", "LOCKED", "RELEASED", "REFUNDED" appeal_count: u256 deadline: str status: str # "ACTIVE", "VERIFIED", "REVERIFIED", "FINALIZED" verification_status: str # "NONE", "FULFILLED", "NOT_FULFILLED", "INSUFFICIENT_EVIDENCE" verification_explanation: str parties_json: str obligations_json: str evidence_json: str results_json: str def _handle_leader_error(leaders_res: gl.vm.Result, leader_fn) -> bool: leader_msg = leaders_res.message if hasattr(leaders_res, "message") else "" try: leader_fn() return False # Leader errored, validator succeeded — disagree except gl.vm.UserError as e: validator_msg = e.message if hasattr(e, "message") else str(e) if validator_msg.startswith(ERROR_EXPECTED): return validator_msg == leader_msg return False except Exception: return False def _parse_llm_json(raw: dict | str) -> dict: if isinstance(raw, dict): return raw if isinstance(raw, str): cleaned = raw.strip() first_brace = cleaned.find("{") last_brace = cleaned.rfind("}") if first_brace != -1 and last_brace != -1: cleaned = cleaned[first_brace : last_brace + 1] try: return json.loads(cleaned) except Exception as e: raise gl.vm.UserError(f"{ERROR_LLM} Failed to parse LLM JSON: {e}") raise gl.vm.UserError(f"{ERROR_LLM} Unexpected LLM output format: {type(raw)}") def _normalize_address(addr) -> Address: if isinstance(addr, Address): return addr if isinstance(addr, (bytes, bytearray)): return Address(addr) if isinstance(addr, str): return Address(addr) return Address(addr) def _normalize_address_str(addr) -> str: if isinstance(addr, Address): return str(addr) if isinstance(addr, (bytes, bytearray)): return str(Address(addr)) if isinstance(addr, str): return str(Address(addr)) if addr.startswith("0x") else addr return str(Address(addr)) def _is_valid_iso_date(val: str) -> bool: if not isinstance(val, str) or len(val) != 10: return False parts = val.split("-") if len(parts) != 3: return False try: year = int(parts[0]) month = int(parts[1]) day = int(parts[2]) return 1900 <= year <= 2100 and 1 <= month <= 12 and 1 <= day <= 31 except (ValueError, TypeError): return False def _parse_integer_safely(val) -> int | None: if val is None: return None if isinstance(val, int) and not isinstance(val, bool): return val try: s = str(val).strip().replace(",", "") if "." in s: return None return int(s) except (ValueError, TypeError): return None def _evaluate_numeric_obligation(ob: dict, extracted: dict) -> dict: target_raw = ob.get("target_value", "0") target_int = _parse_integer_safely(target_raw) if target_int is None: return { "id": ob["obligation_id"], "status": "INSUFFICIENT_EVIDENCE", "evidence_sufficient": False, "rule_type": "NUMERIC", "observed_fact": "", "target_value": target_raw, "comparison_op": ob.get("comparison_op", ">="), "explanation": f"Invalid target_value integer in obligation definition: '{target_raw}'", } if not extracted.get("evidence_sufficient", False): return { "id": ob["obligation_id"], "status": "INSUFFICIENT_EVIDENCE", "evidence_sufficient": False, "rule_type": "NUMERIC", "observed_fact": "", "target_value": str(target_int), "comparison_op": ob.get("comparison_op", ">="), "explanation": str(extracted.get("explanation", "Insufficient evidence for numeric value.")), } raw_observed = extracted.get("observed_numeric") observed_int = _parse_integer_safely(raw_observed) if observed_int is None: return { "id": ob["obligation_id"], "status": "INSUFFICIENT_EVIDENCE", "evidence_sufficient": False, "rule_type": "NUMERIC", "observed_fact": str(raw_observed or ""), "target_value": str(target_int), "comparison_op": ob.get("comparison_op", ">="), "explanation": f"Observed numeric value could not be reliably parsed as integer: '{raw_observed}'", } op = ob.get("comparison_op", ">=").strip() if op == ">=": is_ok = observed_int >= target_int elif op == "<=": is_ok = observed_int <= target_int elif op == "==": is_ok = observed_int == target_int elif op == "<": is_ok = observed_int < target_int elif op == ">": is_ok = observed_int > target_int else: is_ok = observed_int >= target_int return { "id": ob["obligation_id"], "status": "FULFILLED" if is_ok else "NOT_FULFILLED", "evidence_sufficient": True, "rule_type": "NUMERIC", "observed_fact": str(observed_int), "target_value": str(target_int), "comparison_op": op, "explanation": str(extracted.get("explanation", "")), } def _evaluate_deadline_obligation(ob: dict, extracted: dict) -> dict: target_deadline = ob.get("deadline", "") or ob.get("target_value", "") if not _is_valid_iso_date(target_deadline): return { "id": ob["obligation_id"], "status": "INSUFFICIENT_EVIDENCE", "evidence_sufficient": False, "rule_type": "DEADLINE", "observed_fact": "", "target_value": target_deadline, "comparison_op": "<=", "explanation": f"Invalid target deadline date in obligation definition: '{target_deadline}'", } if not extracted.get("evidence_sufficient", False): return { "id": ob["obligation_id"], "status": "INSUFFICIENT_EVIDENCE", "evidence_sufficient": False, "rule_type": "DEADLINE", "observed_fact": "", "target_value": target_deadline, "comparison_op": "<=", "explanation": str(extracted.get("explanation", "Insufficient evidence for delivery date.")), } observed_date = str(extracted.get("observed_date", "")).strip() if not _is_valid_iso_date(observed_date): return { "id": ob["obligation_id"], "status": "INSUFFICIENT_EVIDENCE", "evidence_sufficient": False, "rule_type": "DEADLINE", "observed_fact": observed_date, "target_value": target_deadline, "comparison_op": "<=", "explanation": f"Observed date could not be parsed as valid YYYY-MM-DD: '{observed_date}'", } is_on_or_before = observed_date <= target_deadline return { "id": ob["obligation_id"], "status": "FULFILLED" if is_on_or_before else "NOT_FULFILLED", "evidence_sufficient": True, "rule_type": "DEADLINE", "observed_fact": observed_date, "target_value": target_deadline, "comparison_op": "<=", "explanation": str(extracted.get("explanation", "")), } def _evaluate_semantic_obligation(ob: dict, extracted: dict) -> dict: if not extracted.get("evidence_sufficient", False): return { "id": ob["obligation_id"], "status": "INSUFFICIENT_EVIDENCE", "evidence_sufficient": False, "rule_type": "SEMANTIC", "observed_fact": "INSUFFICIENT_EVIDENCE", "target_value": ob.get("target_value", ""), "comparison_op": "EVAL", "explanation": str(extracted.get("explanation", "Insufficient evidence for semantic compliance.")), } raw_status = str(extracted.get("semantic_status", "INSUFFICIENT_EVIDENCE")).upper().strip() if raw_status not in ("FULFILLED", "NOT_FULFILLED", "INSUFFICIENT_EVIDENCE"): raw_status = "INSUFFICIENT_EVIDENCE" is_suff = raw_status != "INSUFFICIENT_EVIDENCE" return { "id": ob["obligation_id"], "status": raw_status, "evidence_sufficient": is_suff, "rule_type": "SEMANTIC", "observed_fact": raw_status, "target_value": ob.get("target_value", ""), "comparison_op": "EVAL", "explanation": str(extracted.get("explanation", "")), } def _derive_agreement_status(obligation_results: list[dict], obs_defs: list[dict]) -> str: if not obligation_results: return "INSUFFICIENT_EVIDENCE" def_map = {d["obligation_id"]: d for d in obs_defs} mandatory_statuses = [] for r in obligation_results: d = def_map.get(r["id"], {}) if d.get("is_mandatory", True): mandatory_statuses.append(r["status"]) if not mandatory_statuses: return "INSUFFICIENT_EVIDENCE" if any(s == "NOT_FULFILLED" for s in mandatory_statuses): return "NOT_FULFILLED" if any(s == "INSUFFICIENT_EVIDENCE" for s in mandatory_statuses): return "INSUFFICIENT_EVIDENCE" if all(s == "FULFILLED" for s in mandatory_statuses): return "FULFILLED" return "INSUFFICIENT_EVIDENCE" def _run_hybrid_consensus(obs_data: list[dict], ev_data: list[dict]) -> dict: def leader_fn() -> dict: if len(ev_data) == 0: empty_results = [] for ob in obs_data: empty_results.append( { "id": ob["obligation_id"], "status": "INSUFFICIENT_EVIDENCE", "evidence_sufficient": False, "rule_type": ob["rule_type"], "observed_fact": "", "target_value": ob.get("target_value", ""), "comparison_op": ob.get("comparison_op", ">="), "explanation": "No evidence was submitted for this agreement.", } ) return { "agreement_status": "INSUFFICIENT_EVIDENCE", "obligations": empty_results, "explanation": "No evidence submitted to evaluate obligations.", } prompt = f"""You are the ObliGen Intelligent Contract fact extraction engine. Carefully examine the submitted evidence and extract the observed facts for each obligation. AGREEMENT OBLIGATIONS: {json.dumps(obs_data, indent=2)} SUBMITTED EVIDENCE: {json.dumps(ev_data, indent=2)} EXTRACTION INSTRUCTIONS: For each obligation in the agreement, output an object in the "extractions" list: 1. "id": The obligation ID. 2. "evidence_sufficient": true if clear, authentic, unambiguous evidence exists for this obligation. If evidence is missing, unreadable, or contradictory, set false. 3. "observed_numeric": If rule_type is "NUMERIC", extract the exact integer quantity delivered/completed (e.g. 1200). If not mentioned or insufficient, return null. 4. "observed_date": If rule_type is "DEADLINE", extract the exact date of delivery/fulfillment formatted strictly as YYYY-MM-DD (e.g. "2026-08-28"). If not mentioned or insufficient, return null. 5. "semantic_status": If rule_type is "SEMANTIC", evaluate whether the evidence proves fulfillment ("FULFILLED"), non-fulfillment ("NOT_FULFILLED"), or is inconclusive ("INSUFFICIENT_EVIDENCE"). 6. "explanation": Concise summary of the extracted facts and evidence references. Return JSON ONLY in this exact structure: {{ "extractions": [ {{ "id": "obligation_id", "evidence_sufficient": true | false, "observed_numeric": 1000 | null, "observed_date": "YYYY-MM-DD" | null, "semantic_status": "FULFILLED" | "NOT_FULFILLED" | "INSUFFICIENT_EVIDENCE" | null, "explanation": "extracted fact rationale" }} ], "explanation": "overall extraction summary" }}""" raw_response = gl.nondet.exec_prompt(prompt, response_format="json") parsed = _parse_llm_json(raw_response) raw_extractions = parsed.get("extractions", []) if not isinstance(raw_extractions, list): raise gl.vm.UserError( f"{ERROR_LLM} Extractions must be a list in LLM response" ) extracted_map = {} for item in raw_extractions: if isinstance(item, dict) and "id" in item: extracted_map[item["id"]] = item evaluated_obligations = [] for ob in obs_data: oid = ob["obligation_id"] ext = extracted_map.get( oid, {"evidence_sufficient": False, "explanation": "Obligation omitted in extractor response."}, ) rule_type = ob.get("rule_type", "SEMANTIC") if rule_type == "NUMERIC": res = _evaluate_numeric_obligation(ob, ext) elif rule_type == "DEADLINE": res = _evaluate_deadline_obligation(ob, ext) else: res = _evaluate_semantic_obligation(ob, ext) evaluated_obligations.append(res) overall_status = _derive_agreement_status(evaluated_obligations, obs_data) overall_explanation = str(parsed.get("explanation", "")) return { "agreement_status": overall_status, "obligations": evaluated_obligations, "explanation": overall_explanation, } def validator_fn(leaders_res: gl.vm.Result) -> bool: if not isinstance(leaders_res, gl.vm.Return): return _handle_leader_error(leaders_res, leader_fn) leader_data = leaders_res.calldata if not isinstance(leader_data, dict): return False validator_data = leader_fn() if leader_data.get("agreement_status") != validator_data.get("agreement_status"): return False leader_obs = leader_data.get("obligations", []) validator_obs = validator_data.get("obligations", []) if len(leader_obs) != len(validator_obs): return False v_map = {vo["id"]: vo for vo in validator_obs if isinstance(vo, dict) and "id" in vo} for lo in leader_obs: if not isinstance(lo, dict) or "id" not in lo: return False lid = lo["id"] if lid not in v_map: return False vo = v_map[lid] if lo.get("status") != vo.get("status"): return False if lo.get("evidence_sufficient") != vo.get("evidence_sufficient"): return False if lo.get("observed_fact") != vo.get("observed_fact"): return False return True return gl.vm.run_nondet_unsafe(leader_fn, validator_fn) class ObliGen(gl.Contract): owner: Address agreements: TreeMap[str, Agreement] agreement_ids: DynArray[str] def __init__(self): self.owner = gl.message.sender_address @gl.public.write def create_agreement( self, agreement_id: str, parties: list[Address], obligations: list[dict], debtor: Address, creditor: Address, escrow_amount: u256 = u256(0), deadline: str = "", ) -> None: if not agreement_id or agreement_id.strip() == "": raise gl.vm.UserError(f"{ERROR_EXPECTED} Agreement ID cannot be empty") if agreement_id in self.agreements: raise gl.vm.UserError(f"{ERROR_EXPECTED} Agreement '{agreement_id}' already exists") if not parties or len(parties) == 0: raise gl.vm.UserError(f"{ERROR_EXPECTED} Agreement must have at least one party") if not obligations or len(obligations) == 0: raise gl.vm.UserError(f"{ERROR_EXPECTED} Agreement must have at least one obligation") debtor_addr = _normalize_address(debtor) creditor_addr = _normalize_address(creditor) parties_list = [] for p in parties: parties_list.append(_normalize_address_str(p)) debtor_str = _normalize_address_str(debtor_addr) creditor_str = _normalize_address_str(creditor_addr) if debtor_str not in parties_list: parties_list.append(debtor_str) if creditor_str not in parties_list: parties_list.append(creditor_str) seen_obs = set() obs_list = [] for ob_dict in obligations: ob_id = ob_dict.get("obligation_id", "") if not ob_id or ob_id in seen_obs: raise gl.vm.UserError( f"{ERROR_EXPECTED} Invalid or duplicate obligation ID: '{ob_id}'" ) seen_obs.add(ob_id) rule_type = str(ob_dict.get("rule_type", "SEMANTIC")).upper() if rule_type not in ("NUMERIC", "DEADLINE", "SEMANTIC"): raise gl.vm.UserError( f"{ERROR_EXPECTED} Invalid rule_type '{rule_type}'. Must be NUMERIC, DEADLINE, or SEMANTIC" ) resp_party_raw = ob_dict.get("responsible_party") if resp_party_raw is not None: resp_party = _normalize_address_str(resp_party_raw) else: resp_party = str(gl.message.sender_address) ob_entry = { "obligation_id": ob_id, "description": str(ob_dict.get("description", "")), "responsible_party": resp_party, "deadline": str(ob_dict.get("deadline", "")), "rule_type": rule_type, "target_value": str(ob_dict.get("target_value", "")), "comparison_op": str(ob_dict.get("comparison_op", ">=")), "is_mandatory": bool(ob_dict.get("is_mandatory", True)), } obs_list.append(ob_entry) escrow_amt = u256(escrow_amount) escrow_st = "UNFUNDED" if escrow_amt > 0 else "NONE" agreement = Agreement( agreement_id=agreement_id, creator=gl.message.sender_address, debtor=debtor_addr, creditor=creditor_addr, escrow_amount=escrow_amt, escrow_status=escrow_st, appeal_count=u256(0), deadline=deadline, status="ACTIVE", verification_status="NONE", verification_explanation="", parties_json=json.dumps(parties_list), obligations_json=json.dumps(obs_list), evidence_json=json.dumps([]), results_json=json.dumps([]), ) self.agreements[agreement_id] = agreement self.agreement_ids.append(agreement_id) @gl.public.write.payable def fund_escrow(self, agreement_id: str) -> None: if agreement_id not in self.agreements: raise gl.vm.UserError(f"{ERROR_EXPECTED} Agreement '{agreement_id}' not found") agreement = self.agreements[agreement_id] if agreement.status != "ACTIVE": raise gl.vm.UserError( f"{ERROR_EXPECTED} Cannot fund escrow for non-active agreement (status: {agreement.status})" ) sender = gl.message.sender_address if sender != agreement.debtor: raise gl.vm.UserError( f"{ERROR_EXPECTED} Only the designated debtor ({agreement.debtor}) can fund escrow" ) if agreement.escrow_amount <= 0: raise gl.vm.UserError( f"{ERROR_EXPECTED} Agreement '{agreement_id}' has zero escrow and cannot be funded" ) if agreement.escrow_status != "UNFUNDED": raise gl.vm.UserError( f"{ERROR_EXPECTED} Escrow is already funded (status: {agreement.escrow_status})" ) msg_val = gl.message.value if msg_val != agreement.escrow_amount: raise gl.vm.UserError( f"{ERROR_EXPECTED} Incorrect funding amount: expected {agreement.escrow_amount}, received {msg_val}" ) agreement.escrow_status = "FUNDED" self.agreements[agreement_id] = agreement @gl.public.write def submit_evidence( self, agreement_id: str, evidence_id: str, description: str, source_reference: str, content: str, ) -> None: if agreement_id not in self.agreements: raise gl.vm.UserError(f"{ERROR_EXPECTED} Agreement '{agreement_id}' not found") agreement = self.agreements[agreement_id] if agreement.status != "ACTIVE": raise gl.vm.UserError( f"{ERROR_EXPECTED} Cannot submit evidence for non-active agreement (status: {agreement.status})" ) parties = json.loads(agreement.parties_json) sender_str = str(gl.message.sender_address) if sender_str not in parties: raise gl.vm.UserError( f"{ERROR_EXPECTED} Sender {sender_str} is not a recognized party of agreement '{agreement_id}'" ) if not evidence_id or evidence_id.strip() == "": raise gl.vm.UserError(f"{ERROR_EXPECTED} Evidence ID cannot be empty") evidence_list = json.loads(agreement.evidence_json) for ev in evidence_list: if ev.get("evidence_id") == evidence_id: raise gl.vm.UserError( f"{ERROR_EXPECTED} Duplicate evidence ID '{evidence_id}' in agreement '{agreement_id}'" ) new_ev = { "evidence_id": evidence_id, "submitted_by": sender_str, "description": description, "source_reference": source_reference, "content": content, } evidence_list.append(new_ev) agreement.evidence_json = json.dumps(evidence_list) self.agreements[agreement_id] = agreement @gl.public.write def verify(self, agreement_id: str) -> dict: if agreement_id not in self.agreements: raise gl.vm.UserError(f"{ERROR_EXPECTED} Agreement '{agreement_id}' not found") agreement = self.agreements[agreement_id] if agreement.status != "ACTIVE": raise gl.vm.UserError( f"{ERROR_EXPECTED} Agreement '{agreement_id}' is not in ACTIVE state (status: {agreement.status})" ) if agreement.escrow_amount > 0 and agreement.escrow_status != "FUNDED": raise gl.vm.UserError( f"{ERROR_EXPECTED} Cannot verify agreement with unfunded escrow (status: {agreement.escrow_status})" ) obs_data = json.loads(agreement.obligations_json) ev_data = json.loads(agreement.evidence_json) consensus_result = _run_hybrid_consensus(obs_data, ev_data) agreement.status = "VERIFIED" if agreement.escrow_amount > 0: agreement.escrow_status = "LOCKED" agreement.verification_status = consensus_result["agreement_status"] agreement.verification_explanation = consensus_result["explanation"] agreement.results_json = json.dumps(consensus_result["obligations"]) self.agreements[agreement_id] = agreement return consensus_result @gl.public.write def appeal(self, agreement_id: str) -> dict: if agreement_id not in self.agreements: raise gl.vm.UserError(f"{ERROR_EXPECTED} Agreement '{agreement_id}' not found") agreement = self.agreements[agreement_id] parties = json.loads(agreement.parties_json) sender_str = str(gl.message.sender_address) if sender_str not in parties: raise gl.vm.UserError( f"{ERROR_EXPECTED} Sender {sender_str} is not a recognized party of agreement '{agreement_id}'" ) if agreement.status != "VERIFIED": raise gl.vm.UserError( f"{ERROR_EXPECTED} Can only appeal agreements in VERIFIED status (current: {agreement.status})" ) if agreement.appeal_count > 0: raise gl.vm.UserError( f"{ERROR_EXPECTED} Agreement '{agreement_id}' has already been appealed (limit: 1)" ) obs_data = json.loads(agreement.obligations_json) ev_data = json.loads(agreement.evidence_json) # Fresh execution of hybrid consensus fresh_result = _run_hybrid_consensus(obs_data, ev_data) agreement.appeal_count = u256(1) agreement.status = "REVERIFIED" agreement.verification_status = fresh_result["agreement_status"] agreement.verification_explanation = fresh_result["explanation"] agreement.results_json = json.dumps(fresh_result["obligations"]) self.agreements[agreement_id] = agreement return fresh_result @gl.public.write def finalize(self, agreement_id: str) -> None: if agreement_id not in self.agreements: raise gl.vm.UserError(f"{ERROR_EXPECTED} Agreement '{agreement_id}' not found") agreement = self.agreements[agreement_id] if agreement.status not in ("VERIFIED", "REVERIFIED"): raise gl.vm.UserError( f"{ERROR_EXPECTED} Can only finalize agreements in VERIFIED or REVERIFIED status (current: {agreement.status})" ) agreement.status = "FINALIZED" self.agreements[agreement_id] = agreement @gl.public.write def settle(self, agreement_id: str) -> None: if agreement_id not in self.agreements: raise gl.vm.UserError(f"{ERROR_EXPECTED} Agreement '{agreement_id}' not found") agreement = self.agreements[agreement_id] if agreement.status != "FINALIZED": raise gl.vm.UserError( f"{ERROR_EXPECTED} Cannot settle agreement before FINALIZED state (current: {agreement.status})" ) if agreement.escrow_amount <= 0: raise gl.vm.UserError( f"{ERROR_EXPECTED} Agreement '{agreement_id}' has zero escrow to settle" ) if agreement.escrow_status != "LOCKED": raise gl.vm.UserError( f"{ERROR_EXPECTED} Cannot settle escrow with status '{agreement.escrow_status}' (must be LOCKED)" ) if agreement.verification_status == "FULFILLED": recipient = agreement.creditor agreement.escrow_status = "RELEASED" self.agreements[agreement_id] = agreement gl.get_contract_at(recipient).emit_transfer( value=agreement.escrow_amount, on="finalized" ) elif agreement.verification_status == "NOT_FULFILLED": recipient = agreement.debtor agreement.escrow_status = "REFUNDED" self.agreements[agreement_id] = agreement gl.get_contract_at(recipient).emit_transfer( value=agreement.escrow_amount, on="finalized" ) elif agreement.verification_status == "INSUFFICIENT_EVIDENCE": raise gl.vm.UserError( f"{ERROR_EXPECTED} Cannot settle escrow with INSUFFICIENT_EVIDENCE; funds remain LOCKED" ) else: raise gl.vm.UserError( f"{ERROR_EXPECTED} Unknown verification status '{agreement.verification_status}'" ) @gl.public.view def get_agreement(self, agreement_id: str) -> dict: if agreement_id not in self.agreements: raise gl.vm.UserError(f"{ERROR_EXPECTED} Agreement '{agreement_id}' not found") agreement = self.agreements[agreement_id] return { "agreement_id": agreement.agreement_id, "creator": str(agreement.creator), "debtor": str(agreement.debtor), "creditor": str(agreement.creditor), "escrow_amount": int(agreement.escrow_amount), "escrow_status": agreement.escrow_status, "appeal_count": agreement.appeal_count, "deadline": agreement.deadline, "status": agreement.status, "verification_status": agreement.verification_status, "verification_explanation": agreement.verification_explanation, "parties": json.loads(agreement.parties_json), "obligations": json.loads(agreement.obligations_json), "evidence_list": json.loads(agreement.evidence_json), "results": json.loads(agreement.results_json), } @gl.public.view def get_verification(self, agreement_id: str) -> dict: if agreement_id not in self.agreements: raise gl.vm.UserError(f"{ERROR_EXPECTED} Agreement '{agreement_id}' not found") agreement = self.agreements[agreement_id] return { "agreement_id": agreement.agreement_id, "status": agreement.status, "verification_status": agreement.verification_status, "verification_explanation": agreement.verification_explanation, "appeal_count": agreement.appeal_count, "escrow_status": agreement.escrow_status, "obligations": json.loads(agreement.results_json), }