# v.0.2.17 # { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from genlayer import * import json import hashlib from enum import IntEnum # ─── ENUMS ──────────────────────────────────────────────────────────────────── class Role(IntEnum): NONE = 0 BORROWER = 1 LENDER = 2 VALIDATOR = 3 ADMIN = 4 AUDITOR = 5 class LoanStatus(IntEnum): NONE = 0 PENDING = 1 ASSESSING = 2 APPROVED = 3 DECLINED = 4 REVIEW = 5 CANCELLED = 6 FUNDED = 7 REPAID = 8 DEFAULTED = 9 # ─── CONTRACT ───────────────────────────────────────────────────────────────── class TrustLayer(gl.Contract): owner: str paused: bool assessment_fee_gen: u256 min_trust_score_approval: u256 validators_required: u256 consensus_threshold: u256 loan_counter: u256 audit_counter: u256 roles: TreeMap[str, u256] borrowers: TreeMap[str, str] loans: TreeMap[str, str] assessments: TreeMap[str, str] reputation: TreeMap[str, str] audit_log: TreeMap[str, str] supported_currencies: DynArray[str] supported_jurisdictions: DynArray[str] def __init__(self) -> None: self.owner = str(gl.message.sender_address) self.paused = False self.assessment_fee_gen = 10 self.min_trust_score_approval = 65 self.validators_required = 3 self.consensus_threshold = 2 self.loan_counter = 0 self.audit_counter = 0 self.roles[str(gl.message.sender_address)] = int(Role.ADMIN) for c in ["USD", "EUR", "GBP", "NGN", "GHS", "KES", "ZAR", "GEN"]: self.supported_currencies.append(c) for j in ["NG", "GH", "KE", "ZA", "US", "GB", "EU", "GLOBAL"]: self.supported_jurisdictions.append(j) self._add_audit(str(gl.message.sender_address), "DEPLOY", "contract", "TrustLayer deployed") def _require(self, condition: bool, message: str) -> None: if not condition: raise Exception(message) def _loan_id(self, n: int) -> str: return "LOAN-" + str(n).zfill(6) def _audit_id(self, n: int) -> str: return "AUDIT-" + str(n).zfill(6) def _add_audit(self, caller: str, action: str, ref_id: str, detail: str) -> None: entry_id = self._audit_id(int(self.audit_counter)) entry = {"id": entry_id, "actor": caller, "action": action, "ref_id": ref_id, "detail": detail} self.audit_log[entry_id] = json.dumps(entry) self.audit_counter += 1 def _update_reputation(self, wallet: str, loan_id: str, outcome: str, trust_score: int) -> None: raw = self.reputation.get(wallet, "") history = json.loads(raw) if raw else {"entries": [], "average_trust": 0, "total_loans": 0} entries = history["entries"] entries.append({"loan_id": loan_id, "outcome": outcome, "trust_score": trust_score}) total = history["total_loans"] + 1 prev_avg = history["average_trust"] avg = int((prev_avg * (total - 1) + trust_score * 2) / (total + 1)) if total > 1 else trust_score self.reputation[wallet] = json.dumps({"entries": entries, "average_trust": avg, "total_loans": total}) @gl.public.write def set_assessment_fee(self, fee_gen: int) -> None: self._require(str(gl.message.sender_address) == self.owner, "Owner only") self.assessment_fee_gen = fee_gen self._add_audit(str(gl.message.sender_address), "SET_FEE", "contract", "fee=" + str(fee_gen)) @gl.public.write def set_approval_threshold(self, min_score: int) -> None: self._require(str(gl.message.sender_address) == self.owner, "Owner only") self._require(0 <= min_score <= 100, "Score must be 0-100") self.min_trust_score_approval = min_score self._add_audit(str(gl.message.sender_address), "SET_THRESHOLD", "contract", "min_score=" + str(min_score)) @gl.public.write def set_consensus_params(self, validators_required: int, threshold: int) -> None: self._require(str(gl.message.sender_address) == self.owner, "Owner only") self._require(threshold <= validators_required, "Threshold cannot exceed validators required") self.validators_required = validators_required self.consensus_threshold = threshold @gl.public.write def pause(self) -> None: self._require(str(gl.message.sender_address) == self.owner, "Owner only") self.paused = True self._add_audit(str(gl.message.sender_address), "PAUSE", "contract", "Contract paused") @gl.public.write def unpause(self) -> None: self._require(str(gl.message.sender_address) == self.owner, "Owner only") self.paused = False self._add_audit(str(gl.message.sender_address), "UNPAUSE", "contract", "Contract unpaused") @gl.public.write def assign_role(self, wallet: str, role: int) -> None: self._require(str(gl.message.sender_address) == self.owner, "Owner only") self._require(0 <= role <= 5, "Invalid role") self.roles[wallet] = role self._add_audit(str(gl.message.sender_address), "ASSIGN_ROLE", wallet, "role=" + str(role)) @gl.public.write def revoke_role(self, wallet: str) -> None: self._require(str(gl.message.sender_address) == self.owner, "Owner only") self.roles[wallet] = int(Role.NONE) self._add_audit(str(gl.message.sender_address), "REVOKE_ROLE", wallet, "role revoked") @gl.public.write def register_borrower( self, display_name: str, jurisdiction: str, preferred_currency: str, business_type: str, firebase_uid: str, ) -> str: self._require(not self.paused, "Contract is paused") caller = str(gl.message.sender_address) existing = self.borrowers.get(caller, "") self._require(not existing, "Borrower already registered") self._require(jurisdiction in self.supported_jurisdictions, "Unsupported jurisdiction: " + jurisdiction) self._require(preferred_currency in self.supported_currencies, "Unsupported currency: " + preferred_currency) self._require(business_type in ["individual", "sme", "enterprise"], "Invalid business type") profile = { "wallet": caller, "display_name": display_name, "jurisdiction": jurisdiction, "preferred_currency": preferred_currency, "business_type": business_type, "firebase_uid": firebase_uid, "active": True, } self.borrowers[caller] = json.dumps(profile) self.roles[caller] = int(Role.BORROWER) self._add_audit(caller, "REGISTER_BORROWER", caller, "jurisdiction=" + jurisdiction) return caller @gl.public.write def register_lender(self, display_name: str, firebase_uid: str) -> None: self._require(not self.paused, "Contract is paused") caller = str(gl.message.sender_address) existing_role = int(self.roles.get(caller, 0)) self._require(existing_role == int(Role.NONE), "Wallet already has a role assigned") self.roles[caller] = int(Role.LENDER) self._add_audit(caller, "REGISTER_LENDER", caller, "name=" + display_name) @gl.public.write def submit_loan_request( self, amount: int, currency: str, purpose: str, duration_days: int, evidence_hashes: list, community_endorsers: list, jurisdiction: str, ) -> str: self._require(not self.paused, "Contract is paused") caller = str(gl.message.sender_address) self._require(bool(self.borrowers.get(caller, "")), "Must register as borrower first") self._require(amount > 0, "Amount must be positive") self._require(currency in self.supported_currencies, "Unsupported currency: " + currency) self._require(len(purpose) >= 20, "Purpose description too short (min 20 chars)") self._require(1 <= duration_days <= 3650, "Duration must be 1-3650 days") self._require(len(evidence_hashes) >= 1, "At least one evidence document required") self.loan_counter += 1 loan_id = self._loan_id(int(self.loan_counter)) loan = { "id": loan_id, "borrower": caller, "amount": amount, "currency": currency, "purpose": purpose, "duration_days": duration_days, "evidence_hashes": evidence_hashes, "community_endorsers": community_endorsers, "jurisdiction": jurisdiction, "status": int(LoanStatus.PENDING), "lender": None, } self.loans[loan_id] = json.dumps(loan) self._add_audit(caller, "SUBMIT_LOAN", loan_id, str(amount) + " " + currency + " " + str(duration_days) + "d") return loan_id @gl.public.write def cancel_loan_request(self, loan_id: str) -> None: self._require(not self.paused, "Contract is paused") caller = str(gl.message.sender_address) raw = self.loans.get(loan_id, "") self._require(bool(raw), "Loan not found") loan = json.loads(raw) self._require(loan["borrower"] == caller, "Not your loan") self._require(loan["status"] == int(LoanStatus.PENDING), "Can only cancel PENDING loans") loan["status"] = int(LoanStatus.CANCELLED) self.loans[loan_id] = json.dumps(loan) self._add_audit(caller, "CANCEL_LOAN", loan_id, "borrower cancelled") @gl.public.write def trigger_assessment(self, loan_id: str) -> None: self._require(not self.paused, "Contract is paused") caller = str(gl.message.sender_address) raw = self.loans.get(loan_id, "") self._require(bool(raw), "Loan not found") loan = json.loads(raw) caller_role = int(self.roles.get(caller, 0)) self._require( loan["borrower"] == caller or caller_role >= int(Role.ADMIN), "Only borrower or admin can trigger assessment", ) self._require(loan["status"] == int(LoanStatus.PENDING), "Loan must be in PENDING status") loan["status"] = int(LoanStatus.ASSESSING) self.loans[loan_id] = json.dumps(loan) self._add_audit(caller, "TRIGGER_ASSESSMENT", loan_id, "AI assessment started") borrower_raw = self.borrowers.get(loan["borrower"], "") borrower = json.loads(borrower_raw) if borrower_raw else {} rep_raw = self.reputation.get(loan["borrower"], "") reputation = json.loads(rep_raw) if rep_raw else {"average_trust": 50, "total_loans": 0} min_score = int(self.min_trust_score_approval) result = self._run_ai_assessment(loan, borrower, reputation, min_score) self._store_assessment_result(loan_id, loan, result, caller) def _run_ai_assessment(self, loan: dict, borrower: dict, reputation: dict, min_score: int) -> dict: prompt = ( "You are a senior credit analyst AI for TrustLayer, an institutional credit intelligence protocol.\n" "Evaluate this loan request and produce a structured credit assessment.\n\n" "BORROWER PROFILE:\n" "- Business Type: " + str(borrower.get("business_type", "unknown")) + "\n" "- Jurisdiction: " + str(loan["jurisdiction"]) + "\n" "- Previous Loans: " + str(reputation["total_loans"]) + "\n" "- Historical Average Trust Score: " + str(reputation["average_trust"]) + "/100\n\n" "LOAN REQUEST:\n" "- Amount: " + str(loan["amount"]) + " " + str(loan["currency"]) + "\n" "- Purpose: " + str(loan["purpose"]) + "\n" "- Duration: " + str(loan["duration_days"]) + " days\n" "- Evidence Documents: " + str(len(loan["evidence_hashes"])) + " document(s)\n" "- Community Endorsers: " + str(len(loan["community_endorsers"])) + " endorser(s)\n\n" "SCORING (assign points):\n" "1. Revenue stability and business reliability (0-25)\n" "2. Repayment capacity based on amount and duration (0-25)\n" "3. Documentation quality and completeness (0-20)\n" "4. Reputation and historical behavior (0-20)\n" "5. Community trust signals (0-10)\n\n" "Respond with ONLY valid JSON, no markdown, no explanation:\n" '{"trust_score": <0-100>, "risk_score": <0-100>, "risk_level": <"VERY_LOW"|"LOW"|"MEDIUM"|"HIGH"|"VERY_HIGH">, ' '"decision": <"APPROVED"|"DECLINED"|"REVIEW">, "confidence": <0-100>, ' '"scoring_breakdown": {"revenue_stability": <0-25>, "repayment_capacity": <0-25>, ' '"documentation_quality": <0-20>, "reputation_signals": <0-20>, "community_trust": <0-10>}, ' '"risk_factors": [], "positive_signals": [], ' '"reasoning_summary": , ' '"recommended_amount": , "recommended_duration_days": }' ) result_raw = gl.exec_prompt(prompt) try: clean = result_raw.strip() if clean.startswith("```"): lines = clean.split("\n") clean = "\n".join(lines[1:-1]) result = json.loads(clean) except Exception: result = { "trust_score": 40, "risk_score": 70, "risk_level": "HIGH", "decision": "REVIEW", "confidence": 30, "scoring_breakdown": { "revenue_stability": 10, "repayment_capacity": 10, "documentation_quality": 10, "reputation_signals": 5, "community_trust": 5, }, "risk_factors": ["AI parsing error - manual review required"], "positive_signals": [], "reasoning_summary": "Assessment parsing failed. Manual review required.", "recommended_amount": None, "recommended_duration_days": None, } if result["trust_score"] < min_score and result["decision"] == "APPROVED": result["decision"] = "REVIEW" return result def _store_assessment_result(self, loan_id: str, loan: dict, result: dict, caller: str) -> None: decision_str = result.get("decision", "REVIEW") status_map = {"APPROVED": LoanStatus.APPROVED, "DECLINED": LoanStatus.DECLINED, "REVIEW": LoanStatus.REVIEW} new_status = status_map.get(decision_str, LoanStatus.REVIEW) reasoning_hash = hashlib.sha256(result.get("reasoning_summary", "").encode()).hexdigest() assessment = { "loan_id": loan_id, "borrower": loan["borrower"], "trust_score": result["trust_score"], "risk_score": result["risk_score"], "risk_level": result["risk_level"], "decision": decision_str, "confidence": result["confidence"], "scoring_breakdown": result["scoring_breakdown"], "risk_factors": result["risk_factors"], "positive_signals": result["positive_signals"], "reasoning_hash": reasoning_hash, "recommended_amount": result.get("recommended_amount"), "recommended_duration_days": result.get("recommended_duration_days"), } self.assessments[loan_id] = json.dumps(assessment) loan["status"] = int(new_status) self.loans[loan_id] = json.dumps(loan) self._update_reputation(loan["borrower"], loan_id, decision_str, result["trust_score"]) self._add_audit(caller, "ASSESSMENT_COMPLETE", loan_id, "decision=" + decision_str + " trust=" + str(result["trust_score"])) @gl.public.write def fund_loan(self, loan_id: str) -> None: self._require(not self.paused, "Contract is paused") caller = str(gl.message.sender_address) self._require(int(self.roles.get(caller, 0)) == int(Role.LENDER), "Must be a registered lender") raw = self.loans.get(loan_id, "") self._require(bool(raw), "Loan not found") loan = json.loads(raw) self._require(loan["status"] == int(LoanStatus.APPROVED), "Loan must be APPROVED to fund") loan["status"] = int(LoanStatus.FUNDED) loan["lender"] = caller self.loans[loan_id] = json.dumps(loan) self._add_audit(caller, "FUND_LOAN", loan_id, "lender=" + caller) @gl.public.write def mark_repaid(self, loan_id: str) -> None: self._require(not self.paused, "Contract is paused") caller = str(gl.message.sender_address) raw = self.loans.get(loan_id, "") self._require(bool(raw), "Loan not found") loan = json.loads(raw) caller_role = int(self.roles.get(caller, 0)) self._require( loan["lender"] == caller or caller_role == int(Role.ADMIN), "Only lender or admin can mark repaid", ) self._require(loan["status"] == int(LoanStatus.FUNDED), "Loan must be FUNDED") loan["status"] = int(LoanStatus.REPAID) self.loans[loan_id] = json.dumps(loan) self._update_reputation(loan["borrower"], loan_id, "REPAID", 85) self._add_audit(caller, "MARK_REPAID", loan_id, "loan repaid") @gl.public.write def mark_defaulted(self, loan_id: str) -> None: self._require(not self.paused, "Contract is paused") caller = str(gl.message.sender_address) raw = self.loans.get(loan_id, "") self._require(bool(raw), "Loan not found") loan = json.loads(raw) caller_role = int(self.roles.get(caller, 0)) self._require( loan["lender"] == caller or caller_role == int(Role.ADMIN), "Only lender or admin can mark defaulted", ) self._require(loan["status"] == int(LoanStatus.FUNDED), "Loan must be FUNDED") loan["status"] = int(LoanStatus.DEFAULTED) self.loans[loan_id] = json.dumps(loan) self._update_reputation(loan["borrower"], loan_id, "DEFAULTED", 10) self._add_audit(caller, "MARK_DEFAULTED", loan_id, "loan defaulted") @gl.public.write def simulate_assessment( self, borrower_wallet: str, amount: int, currency: str, duration_days: int, purpose: str, ) -> dict: borrower_raw = self.borrowers.get(borrower_wallet, "") borrower = json.loads(borrower_raw) if borrower_raw else {} rep_raw = self.reputation.get(borrower_wallet, "") reputation = json.loads(rep_raw) if rep_raw else {"average_trust": 50, "total_loans": 0} prompt = ( "You are a credit simulation AI for TrustLayer protocol.\n" "Provide a quick estimate (NOT a binding decision).\n\n" "BORROWER HISTORY: " + str(reputation["total_loans"]) + " previous loans, " "avg trust score " + str(reputation["average_trust"]) + "/100\n" "BUSINESS TYPE: " + str(borrower.get("business_type", "unknown")) + "\n" "JURISDICTION: " + str(borrower.get("jurisdiction", "GLOBAL")) + "\n" "AMOUNT: " + str(amount) + " " + str(currency) + "\n" "DURATION: " + str(duration_days) + " days\n" "PURPOSE: " + str(purpose) + "\n\n" "Respond with ONLY valid JSON:\n" '{"approval_probability": <0-100>, "estimated_trust_score": <0-100>, ' '"risk_level": <"VERY_LOW"|"LOW"|"MEDIUM"|"HIGH"|"VERY_HIGH">, ' '"recommended_amount": , "recommended_duration_days": , ' '"key_factors": []}' ) result_raw = gl.exec_prompt(prompt) try: clean = result_raw.strip() if clean.startswith("```"): lines = clean.split("\n") clean = "\n".join(lines[1:-1]) return json.loads(clean) except Exception: return { "approval_probability": 50, "estimated_trust_score": 50, "risk_level": "MEDIUM", "recommended_amount": amount, "recommended_duration_days": duration_days, "key_factors": ["Simulation unavailable - try again"], } @gl.public.view def get_borrower(self, wallet: str) -> str: return self.borrowers.get(wallet, "{}") @gl.public.view def get_loan(self, loan_id: str) -> str: return self.loans.get(loan_id, "{}") @gl.public.view def get_assessment(self, loan_id: str) -> str: return self.assessments.get(loan_id, "{}") @gl.public.view def get_reputation(self, wallet: str) -> str: raw = self.reputation.get(wallet, "") return raw if raw else '{"entries": [], "average_trust": 0, "total_loans": 0}' @gl.public.view def get_role(self, wallet: str) -> int: return int(self.roles.get(wallet, 0)) @gl.public.view def get_audit_entry(self, entry_id: str) -> str: return self.audit_log.get(entry_id, "{}") @gl.public.view def get_audit_count(self) -> int: return int(self.audit_counter) @gl.public.view def get_loan_counter(self) -> int: return int(self.loan_counter) @gl.public.view def get_contract_params(self) -> str: params = { "owner": self.owner, "paused": self.paused, "assessment_fee_gen": int(self.assessment_fee_gen), "min_trust_score_approval": int(self.min_trust_score_approval), "validators_required": int(self.validators_required), "consensus_threshold": int(self.consensus_threshold), } return json.dumps(params) @gl.public.view def is_paused(self) -> bool: return self.paused @gl.public.view def get_trust_score(self, loan_id: str) -> int: raw = self.assessments.get(loan_id, "") if not raw: return -1 a = json.loads(raw) return a.get("trust_score", -1)