# v0.2.18 # { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from genlayer import * import json import hashlib DECISIONS = ("approve", "conditional_approve", "reject") RISK_LEVELS = ("low", "medium", "high") APPEAL_OUTCOMES = ("uphold", "improve", "worsen", "insufficient_new_evidence") class Fiducia(gl.Contract): """ Fiducia — GenLayer Intelligent Underwriting Contract GenLayer-native decentralized underwriting layer. - No backend required - No escrow - No loan funding - GEN uses 18 decimals - GenLayer consensus is used for meaningful non-deterministic underwriting judgement """ cases: TreeMap[str, str] case_evidence: TreeMap[str, str] case_verdicts: TreeMap[str, str] appeals: TreeMap[str, str] appeal_verdicts: TreeMap[str, str] borrower_cases: TreeMap[str, str] borrower_reputation: TreeMap[str, str] protocol_flags: TreeMap[str, str] total_cases: u256 total_reviews: u256 total_appeals: u256 review_fee: u256 admin: Address paused: bool def __init__(self) -> None: self.total_cases = u256(0) self.total_reviews = u256(0) self.total_appeals = u256(0) # GEN has 18 decimals. # 1 GEN = 1_000_000_000_000_000_000 # 0.001 GEN = 1_000_000_000_000_000 self.review_fee = u256(1_000_000_000_000_000) self.admin = gl.message.sender_address self.paused = False # ------------------------------------------------------------------------- # Internal helpers # ------------------------------------------------------------------------- def _require(self, cond: bool, msg: str) -> None: if not cond: raise gl.vm.UserError(msg) def _require_not_paused(self) -> None: self._require(not self.paused, "Protocol is paused") def _require_admin(self) -> None: self._require(gl.message.sender_address == self.admin, "Admin only") def _sender_hex(self) -> str: return gl.message.sender_address.as_hex def _loads(self, raw: str, msg: str) -> dict: try: data = json.loads(raw) except Exception: raise gl.vm.UserError(msg) self._require(isinstance(data, dict), msg) return data def _dumps(self, data) -> str: return json.dumps(data, sort_keys=True, separators=(",", ":")) def _get_case(self, case_id: str) -> dict: self._require(case_id in self.cases, "Case not found") return self._loads(self.cases[case_id], "Stored case is invalid") def _save_case(self, case_id: str, case: dict) -> None: self.cases[case_id] = self._dumps(case) def _compute_commitment(self, evidence_json: str, salt: str) -> str: return "0x" + hashlib.sha256((evidence_json + salt).encode()).hexdigest() def _validate_text(self, value: str, field: str, min_len: int, max_len: int) -> None: self._require(isinstance(value, str), f"{field} must be a string") cleaned = value.strip() self._require(len(cleaned) >= min_len, f"{field} is too short") self._require(len(cleaned) <= max_len, f"{field} is too long") def _validate_commitment(self, commitment: str) -> None: self._require(isinstance(commitment, str), "commitment must be a string") self._require( len(commitment) == 66 and commitment.startswith("0x"), "commitment must be a 0x sha256 hash", ) def _validate_string_array(self, value, field: str, min_items: int, max_items: int) -> None: self._require(isinstance(value, list), f"{field} must be an array") self._require(len(value) >= min_items, f"{field} has too few items") self._require(len(value) <= max_items, f"{field} has too many items") for item in value: self._require( isinstance(item, str) and len(item.strip()) > 0, f"{field} contains an invalid item", ) self._require(len(item) <= 300, f"{field} item is too long") def _validate_number_range(self, value, field: str, low: int, high: int) -> None: self._require( isinstance(value, (int, float)) and not isinstance(value, bool), f"{field} must be numeric", ) self._require(low <= value <= high, f"{field} out of range") def _validate_non_negative_number(self, value, field: str) -> None: self._require( isinstance(value, (int, float)) and not isinstance(value, bool), f"{field} must be numeric", ) self._require(value >= 0, f"{field} cannot be negative") def _validate_evidence(self, evidence: dict) -> None: """ Evidence is intentionally flexible because different SMEs have different proof. But it must be sanitised, structured, bounded, and meaningful. """ allowed_keys = ( "monthly_revenue", "monthly_expenses", "cashflow_summary", "bank_statement_summary", "sales_records_summary", "existing_debts", "repayment_history", "business_assets", "customer_concentration", "supplier_reliability", "owner_experience", "business_location", "market_context", "negative_events", "positive_events", "notes", ) self._require(isinstance(evidence, dict), "Evidence must be a JSON object") self._require(len(evidence.keys()) > 0, "Evidence cannot be empty") self._require(len(evidence.keys()) <= 25, "Evidence has too many fields") for key in evidence.keys(): self._require(isinstance(key, str), "Evidence key must be a string") self._require(len(key) <= 80, "Evidence key too long") has_meaningful_signal = False for key in allowed_keys: if key in evidence and evidence[key] not in ("", None, [], {}): has_meaningful_signal = True self._require( has_meaningful_signal, "Evidence must include at least one meaningful underwriting signal", ) raw_len = len(self._dumps(evidence)) self._require(raw_len <= 12000, "Evidence is too large") def _update_borrower_cases(self, borrower: str, case_id: str) -> None: if borrower in self.borrower_cases: case_ids = json.loads(self.borrower_cases[borrower]) else: case_ids = [] if case_id not in case_ids: case_ids.append(case_id) self.borrower_cases[borrower] = self._dumps(case_ids) def _empty_reputation(self, borrower: str) -> dict: return { "borrower": borrower, "total_reviewed_cases": 0, "approved_count": 0, "conditional_count": 0, "rejected_count": 0, "average_credit_score": 0, "average_repayment_probability": 0, "last_risk_level": "", "last_decision": "", "last_reviewed_case_id": "", } def _update_reputation(self, borrower: str, verdict: dict, case_id: str) -> None: if borrower in self.borrower_reputation: rep = json.loads(self.borrower_reputation[borrower]) else: rep = self._empty_reputation(borrower) rep["total_reviewed_cases"] = int(rep.get("total_reviewed_cases", 0)) + 1 decision = verdict.get("decision", "") if decision == "approve": rep["approved_count"] = int(rep.get("approved_count", 0)) + 1 elif decision == "conditional_approve": rep["conditional_count"] = int(rep.get("conditional_count", 0)) + 1 elif decision == "reject": rep["rejected_count"] = int(rep.get("rejected_count", 0)) + 1 n = int(rep["total_reviewed_cases"]) prev_score_total = float(rep.get("average_credit_score", 0)) * (n - 1) rep["average_credit_score"] = round( (prev_score_total + float(verdict.get("credit_score", 0))) / n, 2, ) prev_prob_total = float(rep.get("average_repayment_probability", 0)) * (n - 1) rep["average_repayment_probability"] = round( (prev_prob_total + float(verdict.get("repayment_probability", 0))) / n, 2, ) rep["last_risk_level"] = verdict.get("risk_level", "") rep["last_decision"] = decision rep["last_reviewed_case_id"] = case_id self.borrower_reputation[borrower] = self._dumps(rep) def _validate_terms(self, terms: dict, requested_amount: int) -> None: self._require(isinstance(terms, dict), "recommended_terms must be an object") self._validate_non_negative_number( terms.get("max_loan_amount"), "recommended_terms.max_loan_amount", ) self._validate_non_negative_number( terms.get("interest_rate"), "recommended_terms.interest_rate", ) self._validate_non_negative_number( terms.get("loan_duration_months"), "recommended_terms.loan_duration_months", ) self._require(terms["loan_duration_months"] <= 120, "recommended loan duration too long") self._require(terms["interest_rate"] <= 100, "recommended interest rate too high") if "conditions" not in terms: terms["conditions"] = [] self._validate_string_array(terms["conditions"], "recommended_terms.conditions", 0, 10) self._require( terms["max_loan_amount"] <= requested_amount * 2, "recommended max loan amount is unreasonably above requested amount", ) def _validate_verdict(self, verdict: dict, requested_amount: int) -> None: self._validate_number_range(verdict.get("credit_score"), "credit_score", 0, 100) self._validate_number_range(verdict.get("confidence"), "confidence", 0, 100) self._validate_number_range( verdict.get("repayment_probability"), "repayment_probability", 0, 100, ) self._require(verdict.get("risk_level") in RISK_LEVELS, "Invalid risk_level") self._require(verdict.get("decision") in DECISIONS, "Invalid decision") self._validate_string_array(verdict.get("reasoning"), "reasoning", 3, 10) self._validate_string_array(verdict.get("risk_flags"), "risk_flags", 0, 10) self._validate_string_array(verdict.get("positive_signals"), "positive_signals", 0, 10) self._validate_terms(verdict.get("recommended_terms"), requested_amount) cs = float(verdict["credit_score"]) rp = float(verdict["repayment_probability"]) confidence = float(verdict["confidence"]) risk = verdict["risk_level"] decision = verdict["decision"] max_loan = float(verdict["recommended_terms"]["max_loan_amount"]) self._require(confidence >= 35, "confidence too low for final underwriting verdict") if decision == "approve": self._require(rp >= 45, "approve inconsistent with repayment_probability below 45") self._require(cs >= 40, "approve inconsistent with credit_score below 40") self._require(risk in ("low", "medium"), "approve inconsistent with high risk") if decision == "conditional_approve": self._require( max_loan > 0, "conditional approval must recommend a positive max loan amount", ) self._require( len(verdict["recommended_terms"]["conditions"]) > 0, "conditional approval requires conditions", ) if decision == "reject": self._require( rp <= 65 or cs <= 65 or risk == "high", "reject lacks supporting risk basis", ) if risk == "high": self._require(decision != "approve", "high risk cannot be directly approved") self._require( max_loan <= requested_amount, "high risk max loan should not exceed requested amount", ) if rp < 45: self._require(decision != "approve", "repayment_probability below 45 cannot be approved") def _validate_appeal_verdict(self, appeal_verdict: dict) -> None: self._require( appeal_verdict.get("appeal_outcome") in APPEAL_OUTCOMES, "Invalid appeal_outcome", ) self._validate_number_range( appeal_verdict.get("revised_credit_score"), "revised_credit_score", 0, 100, ) self._validate_number_range(appeal_verdict.get("confidence"), "confidence", 0, 100) self._require( appeal_verdict.get("revised_risk_level") in RISK_LEVELS, "Invalid revised_risk_level", ) self._require( appeal_verdict.get("revised_decision") in DECISIONS, "Invalid revised_decision", ) self._validate_string_array(appeal_verdict.get("reasoning"), "reasoning", 3, 10) changed_terms = appeal_verdict.get("changed_terms") self._require(isinstance(changed_terms, dict), "changed_terms must be an object") self._validate_non_negative_number( changed_terms.get("max_loan_amount"), "changed_terms.max_loan_amount", ) self._validate_non_negative_number( changed_terms.get("interest_rate"), "changed_terms.interest_rate", ) self._validate_non_negative_number( changed_terms.get("loan_duration_months"), "changed_terms.loan_duration_months", ) if "conditions" not in changed_terms: changed_terms["conditions"] = [] self._validate_string_array(changed_terms["conditions"], "changed_terms.conditions", 0, 10) self._require(float(appeal_verdict["confidence"]) >= 35, "appeal confidence too low") # ------------------------------------------------------------------------- # Case lifecycle # ------------------------------------------------------------------------- @gl.public.write def create_case( self, business_name: str, business_type: str, loan_amount_requested: u256, loan_duration_months_requested: u256, loan_purpose: str, business_age_months: u256, ) -> str: self._require_not_paused() self._validate_text(business_name, "business_name", 2, 120) self._validate_text(business_type, "business_type", 2, 80) self._validate_text(loan_purpose, "loan_purpose", 5, 500) amount = int(loan_amount_requested) duration = int(loan_duration_months_requested) age = int(business_age_months) self._require(amount > 0, "loan_amount_requested must be greater than zero") self._require(duration > 0 and duration <= 120, "invalid loan_duration_months_requested") self._require(age >= 0 and age <= 1200, "invalid business_age_months") self.total_cases = u256(int(self.total_cases) + 1) case_id = str(int(self.total_cases)) borrower = self._sender_hex() case = { "case_id": case_id, "borrower": borrower, "business_name": business_name.strip(), "business_type": business_type.strip(), "loan_amount_requested": amount, "loan_duration_months_requested": duration, "loan_purpose": loan_purpose.strip(), "business_age_months": age, "evidence_commitment": "", "evidence_schema_version": "FIDUCIA_SANITISED_V1", "status": "CREATED", "created_at": 0, "updated_at": 0, } self._save_case(case_id, case) self._update_borrower_cases(borrower, case_id) return case_id @gl.public.write def commit_evidence(self, case_id: str, commitment: str) -> None: self._require_not_paused() self._validate_commitment(commitment) case = self._get_case(case_id) self._require( case["borrower"] == self._sender_hex(), "Only borrower can commit evidence", ) self._require(case["status"] == "CREATED", "Cannot commit evidence in current status") case["evidence_commitment"] = commitment case["status"] = "COMMITTED" self._save_case(case_id, case) @gl.public.write def reveal_evidence(self, case_id: str, evidence_json: str, salt: str) -> None: self._require_not_paused() case = self._get_case(case_id) self._require( case["borrower"] == self._sender_hex(), "Only borrower can reveal evidence", ) self._require(case["status"] == "COMMITTED", "Evidence not in committed state") computed = self._compute_commitment(evidence_json, salt) self._require(computed == case["evidence_commitment"], "Invalid reveal: commitment mismatch") evidence = self._loads(evidence_json, "Evidence must be valid JSON object") self._validate_evidence(evidence) self.case_evidence[case_id] = self._dumps(evidence) case["status"] = "READY_FOR_REVIEW" self._save_case(case_id, case) @gl.public.write def cancel_case(self, case_id: str) -> None: self._require_not_paused() case = self._get_case(case_id) self._require( case["borrower"] == self._sender_hex(), "Only borrower can cancel case", ) self._require( case["status"] not in ( "UNDER_REVIEW", "REVIEWED", "APPEAL_UNDER_REVIEW", "APPEAL_REVIEWED", ), "Cannot cancel after review has started", ) case["status"] = "CANCELLED" self._save_case(case_id, case) # ------------------------------------------------------------------------- # GenLayer AI underwriting review # ------------------------------------------------------------------------- @gl.public.write.payable def trigger_review(self, case_id: str) -> None: self._require_not_paused() case = self._get_case(case_id) self._require(case["status"] == "READY_FOR_REVIEW", "Case is not ready for review") self._require(case_id not in self.case_verdicts, "Case has already been reviewed") self._require(int(gl.message.value) >= int(self.review_fee), "Insufficient review fee") self._require(case_id in self.case_evidence, "Evidence not revealed") case["status"] = "UNDER_REVIEW" self._save_case(case_id, case) evidence = json.loads(self.case_evidence[case_id]) requested_amount = int(case["loan_amount_requested"]) prompt = f""" You are a decentralized SME credit underwriter inside the GenLayer consensus network. Your job is to produce a judgement-based underwriting verdict from sanitised borrower evidence. This must NOT be a rigid deterministic scorecard. Use holistic judgement. CASE: - Case ID: {case["case_id"]} - Business Name: {case["business_name"]} - Business Type: {case["business_type"]} - Business Age Months: {case["business_age_months"]} - Requested Loan Amount: {case["loan_amount_requested"]} - Requested Duration Months: {case["loan_duration_months_requested"]} - Loan Purpose: {case["loan_purpose"]} SANITISED EVIDENCE: {json.dumps(evidence, sort_keys=True, indent=2)} ASSESS: - Repayment likelihood - Cash-flow reliability - Business stability - Revenue quality - Debt pressure - Owner/business behaviour - Positive trajectory - Downside risk - Whether the requested amount and duration are reasonable Return ONLY valid JSON. No markdown. No explanation outside JSON. Schema: {{ "credit_score": , "risk_level": "", "decision": "", "confidence": , "repayment_probability": , "recommended_terms": {{ "max_loan_amount": , "interest_rate": , "loan_duration_months": , "conditions": [, ...] }}, "reasoning": [], "risk_flags": [, ...], "positive_signals": [, ...] }} Rules: - approve requires repayment_probability >= 45 and credit_score >= 40. - approve must not be high risk. - conditional_approve must include at least one condition. - high risk should usually reduce max_loan_amount below the requested amount. - if repayment_probability < 45, decision must not be approve. - reasoning must be specific to the evidence, not generic. """ def underwrite() -> str: return gl.nondet.exec_prompt(prompt) result = gl.eq_principle.prompt_comparative( underwrite, "Do both outputs reach the same underwriting decision, similar risk level, and credit score within 15 points?", ) verdict = self._loads(result, "Validator returned invalid underwriting JSON") self._validate_verdict(verdict, requested_amount) verdict["case_id"] = case_id verdict["borrower"] = case["borrower"] verdict["reviewed_by_trigger"] = self._sender_hex() verdict["schema_version"] = "FIDUCIA_UNDERWRITING_VERDICT_V1" self.case_verdicts[case_id] = self._dumps(verdict) self.total_reviews = u256(int(self.total_reviews) + 1) case["status"] = "REVIEWED" self._save_case(case_id, case) self._update_reputation(case["borrower"], verdict, case_id) # ------------------------------------------------------------------------- # Appeal lifecycle # ------------------------------------------------------------------------- @gl.public.write def commit_appeal(self, case_id: str, appeal_commitment: str) -> None: self._require_not_paused() self._validate_commitment(appeal_commitment) case = self._get_case(case_id) self._require( case["borrower"] == self._sender_hex(), "Only borrower can appeal", ) self._require(case["status"] == "REVIEWED", "Can only appeal after original verdict") self._require(case_id in self.case_verdicts, "Original verdict missing") self._require(case_id not in self.appeal_verdicts, "Appeal already reviewed") appeal = { "case_id": case_id, "borrower": case["borrower"], "appeal_commitment": appeal_commitment, "status": "APPEAL_COMMITTED", } self.appeals[case_id] = self._dumps(appeal) case["status"] = "APPEAL_COMMITTED" self._save_case(case_id, case) @gl.public.write def reveal_appeal(self, case_id: str, appeal_evidence_json: str, salt: str) -> None: self._require_not_paused() case = self._get_case(case_id) self._require( case["borrower"] == self._sender_hex(), "Only borrower can reveal appeal", ) self._require(case["status"] == "APPEAL_COMMITTED", "Appeal not in committed state") self._require(case_id in self.appeals, "Appeal not found") appeal = json.loads(self.appeals[case_id]) computed = self._compute_commitment(appeal_evidence_json, salt) self._require(computed == appeal["appeal_commitment"], "Invalid appeal reveal: commitment mismatch") appeal_evidence = self._loads(appeal_evidence_json, "Appeal evidence must be valid JSON object") self._validate_evidence(appeal_evidence) appeal["appeal_evidence_json"] = self._dumps(appeal_evidence) appeal["status"] = "APPEAL_REVEALED" self.appeals[case_id] = self._dumps(appeal) case["status"] = "READY_FOR_APPEAL_REVIEW" self._save_case(case_id, case) @gl.public.write.payable def trigger_appeal_review(self, case_id: str) -> None: self._require_not_paused() case = self._get_case(case_id) self._require(case["status"] == "READY_FOR_APPEAL_REVIEW", "Case not ready for appeal review") self._require(case_id in self.appeals, "Appeal not found") self._require(case_id in self.case_verdicts, "Original verdict missing") self._require(case_id not in self.appeal_verdicts, "Appeal already reviewed") self._require(int(gl.message.value) >= int(self.review_fee), "Insufficient review fee") appeal = json.loads(self.appeals[case_id]) original_verdict = json.loads(self.case_verdicts[case_id]) appeal_evidence = json.loads(appeal["appeal_evidence_json"]) case["status"] = "APPEAL_UNDER_REVIEW" self._save_case(case_id, case) appeal["status"] = "APPEAL_UNDER_REVIEW" self.appeals[case_id] = self._dumps(appeal) prompt = f""" You are a decentralized credit appeal underwriter inside the GenLayer consensus network. The borrower is appealing an existing underwriting verdict using new sanitised evidence. Your task is to judge whether the new evidence materially changes the credit picture. ORIGINAL CASE: - Case ID: {case["case_id"]} - Business Name: {case["business_name"]} - Business Type: {case["business_type"]} - Requested Loan Amount: {case["loan_amount_requested"]} - Requested Duration Months: {case["loan_duration_months_requested"]} - Loan Purpose: {case["loan_purpose"]} ORIGINAL VERDICT: {json.dumps(original_verdict, sort_keys=True, indent=2)} NEW APPEAL EVIDENCE: {json.dumps(appeal_evidence, sort_keys=True, indent=2)} Return ONLY valid JSON. No markdown. No explanation outside JSON. Schema: {{ "appeal_outcome": "", "revised_credit_score": , "revised_risk_level": "", "revised_decision": "", "confidence": , "reasoning": [], "changed_terms": {{ "max_loan_amount": , "interest_rate": , "loan_duration_months": , "conditions": [, ...] }} }} Rules: - uphold means the original verdict still stands. - improve means the borrower now looks materially better. - worsen means the new evidence reveals greater risk. - insufficient_new_evidence means the appeal evidence does not justify a change. - reasoning must explain why the appeal changed or did not change the original verdict. """ def review_appeal() -> str: return gl.nondet.exec_prompt(prompt) result = gl.eq_principle.prompt_comparative( review_appeal, "Do both outputs reach the same appeal outcome, similar revised risk level, and revised credit score within 15 points?", ) appeal_verdict = self._loads(result, "Validator returned invalid appeal JSON") self._validate_appeal_verdict(appeal_verdict) appeal_verdict["case_id"] = case_id appeal_verdict["borrower"] = case["borrower"] appeal_verdict["reviewed_by_trigger"] = self._sender_hex() appeal_verdict["schema_version"] = "FIDUCIA_APPEAL_VERDICT_V1" self.appeal_verdicts[case_id] = self._dumps(appeal_verdict) self.total_appeals = u256(int(self.total_appeals) + 1) case["status"] = "APPEAL_REVIEWED" self._save_case(case_id, case) appeal["status"] = "APPEAL_REVIEWED" self.appeals[case_id] = self._dumps(appeal) if appeal_verdict["appeal_outcome"] in ("improve", "worsen"): revised = { "credit_score": appeal_verdict["revised_credit_score"], "risk_level": appeal_verdict["revised_risk_level"], "decision": appeal_verdict["revised_decision"], "repayment_probability": original_verdict.get("repayment_probability", 0), } self._update_reputation(case["borrower"], revised, case_id) # ------------------------------------------------------------------------- # Admin methods # ------------------------------------------------------------------------- @gl.public.write def set_review_fee(self, new_fee: u256) -> None: self._require_admin() self.review_fee = new_fee @gl.public.write def pause(self) -> None: self._require_admin() self.paused = True @gl.public.write def unpause(self) -> None: self._require_admin() self.paused = False @gl.public.write def flag_case(self, case_id: str, reason: str) -> None: self._require_admin() self._validate_text(reason, "reason", 3, 500) case = self._get_case(case_id) self.protocol_flags[case_id] = self._dumps({ "case_id": case_id, "reason": reason.strip(), "flagged_by": self.admin.as_hex, }) case["status"] = "FLAGGED" self._save_case(case_id, case) # ------------------------------------------------------------------------- # Views # ------------------------------------------------------------------------- @gl.public.view def get_case(self, case_id: str) -> str: if case_id not in self.cases: return json.dumps(None) return self.cases[case_id] @gl.public.view def get_case_evidence(self, case_id: str) -> str: """ Returns sanitised evidence. Important: On-chain data is public. Fiducia should only store sanitised evidence summaries, not private raw bank statements, identity documents, or PII. """ if case_id not in self.case_evidence: return json.dumps(None) return self.case_evidence[case_id] @gl.public.view def get_case_verdict(self, case_id: str) -> str: if case_id not in self.case_verdicts: return json.dumps(None) return self.case_verdicts[case_id] @gl.public.view def get_appeal(self, case_id: str) -> str: if case_id not in self.appeals: return json.dumps(None) appeal = json.loads(self.appeals[case_id]) if "appeal_evidence_json" in appeal: appeal["appeal_evidence_revealed"] = True del appeal["appeal_evidence_json"] else: appeal["appeal_evidence_revealed"] = False return self._dumps(appeal) @gl.public.view def get_appeal_verdict(self, case_id: str) -> str: if case_id not in self.appeal_verdicts: return json.dumps(None) return self.appeal_verdicts[case_id] @gl.public.view def get_borrower_cases(self, address: str) -> str: if address not in self.borrower_cases: return json.dumps([]) case_ids = json.loads(self.borrower_cases[address]) results = [] for cid in case_ids: if cid in self.cases: results.append(json.loads(self.cases[cid])) return self._dumps(results) @gl.public.view def get_borrower_reputation(self, address: str) -> str: if address not in self.borrower_reputation: return json.dumps(None) return self.borrower_reputation[address] @gl.public.view def get_reviewed_cases(self) -> str: results = [] for case_id in self.case_verdicts: if case_id in self.cases: case = json.loads(self.cases[case_id]) if case["status"] in ("REVIEWED", "APPEAL_REVIEWED"): item = { "case": case, "verdict": json.loads(self.case_verdicts[case_id]), "appeal_verdict": None, } if case_id in self.appeal_verdicts: item["appeal_verdict"] = json.loads(self.appeal_verdicts[case_id]) results.append(item) return self._dumps(results) @gl.public.view def get_protocol_flag(self, case_id: str) -> str: if case_id not in self.protocol_flags: return json.dumps(None) return self.protocol_flags[case_id] @gl.public.view def get_protocol_stats(self) -> str: return self._dumps({ "total_cases": int(self.total_cases), "total_reviews": int(self.total_reviews), "total_appeals": int(self.total_appeals), "review_fee": int(self.review_fee), "review_fee_unit": "GEN_18_DECIMALS", "paused": self.paused, "admin": self.admin.as_hex, })