# v0.2.16 # { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from genlayer import * import typing import json @gl.evm.contract_interface class _Recipient: class View: pass class Write: pass class ReclaimIt(gl.Contract): bounty_count: u256 claim_count: u256 bounty_owner: TreeMap[u256, str] bounty_title: TreeMap[u256, str] bounty_category: TreeMap[u256, str] bounty_description: TreeMap[u256, str] bounty_last_seen: TreeMap[u256, str] bounty_reference_url: TreeMap[u256, str] bounty_reference_commitment: TreeMap[u256, str] bounty_reference_locked_at: TreeMap[u256, u256] bounty_reward: TreeMap[u256, u256] bounty_status: TreeMap[u256, str] bounty_active_claim: TreeMap[u256, u256] bounty_has_active_claim: TreeMap[u256, u256] bounty_paid: TreeMap[u256, u256] bounty_refunded: TreeMap[u256, u256] claim_bounty: TreeMap[u256, u256] claim_finder: TreeMap[u256, str] claim_evidence_url: TreeMap[u256, str] claim_evidence_commitment: TreeMap[u256, str] claim_evidence_locked_at: TreeMap[u256, u256] claim_found_area: TreeMap[u256, str] claim_note: TreeMap[u256, str] claim_handoff_commitment: TreeMap[u256, str] claim_status: TreeMap[u256, str] claim_verdict: TreeMap[u256, str] claim_reason: TreeMap[u256, str] claim_deadline: TreeMap[u256, u256] claim_review_after: TreeMap[u256, u256] claim_owner_release: TreeMap[u256, u256] claim_finder_release: TreeMap[u256, u256] total_received: u256 active_escrow: u256 total_paid: u256 total_refunded: u256 def __init__(self): self.bounty_count = u256(0) self.claim_count = u256(0) self.total_received = u256(0) self.active_escrow = u256(0) self.total_paid = u256(0) self.total_refunded = u256(0) def _now(self) -> u256: raw = str(gl.message_raw["datetime"]) year = int(raw[0:4]) month = int(raw[5:7]) day = int(raw[8:10]) hour = int(raw[11:13]) minute = int(raw[14:16]) second = int(raw[17:19]) adjusted_year = year - (1 if month <= 2 else 0) era = adjusted_year // 400 year_of_era = adjusted_year - era * 400 shifted_month = month - 3 if month > 2 else month + 9 day_of_year = (153 * shifted_month + 2) // 5 + day - 1 day_of_era = ( year_of_era * 365 + year_of_era // 4 - year_of_era // 100 + day_of_year ) days_since_epoch = era * 146097 + day_of_era - 719468 return u256(days_since_epoch * 86400 + hour * 3600 + minute * 60 + second) def _source_id(self, value: str) -> str: lowered = value.lower() if lowered.startswith("https://ipfs.io/ipfs/"): return lowered[len("https://ipfs.io/ipfs/"):].split("/")[0] if lowered.startswith("https://arweave.net/"): return lowered[len("https://arweave.net/"):].split("/")[0] return "" def _valid_source(self, value: str) -> bool: source_id = self._source_id(value) return ( len(value) <= 500 and len(source_id) >= 32 and "example" not in source_id and "replace" not in source_id ) def _valid_content_commitment(self, url: str, commitment: str) -> bool: source_id = self._source_id(url) return source_id != "" and commitment.lower() == ("content:" + source_id) def _valid_handoff_commitment(self, value: str) -> bool: lowered = value.lower() return lowered.startswith("sha256:") and len(lowered) == 71 def _is_claim_party(self, claim_id: u256, sender: str) -> bool: bounty_id = self.claim_bounty[claim_id] return ( sender == self.bounty_owner[bounty_id] or sender == self.claim_finder[claim_id] ) def _reopen_bounty(self, claim_id: u256, claim_status: str, reason: str): bounty_id = self.claim_bounty[claim_id] self.claim_status[claim_id] = claim_status self.claim_reason[claim_id] = reason self.bounty_status[bounty_id] = "OPEN" self.bounty_has_active_claim[bounty_id] = u256(0) def _reject_deposit(self, sender: str, amount: u256, reason: str) -> str: # Attached value is credited before validation on Studionet. Return it # explicitly so an invalid payable call cannot strand unaccounted GEN. if amount > u256(0): _Recipient(Address(sender)).emit_transfer(value=amount) return reason @gl.public.write.payable def open_reward( self, title: str, category: str, public_description: str, last_seen_area: str, reference_url: str, reference_commitment: str, ) -> typing.Any: owner = gl.message.sender_address.as_hex.lower() amount = gl.message.value normalized_category = category.upper() if len(title) < 4 or len(title) > 100: return self._reject_deposit(owner, amount, "INVALID_TITLE") if normalized_category not in ("PET", "WALLET", "PERSONAL_ITEM"): return self._reject_deposit(owner, amount, "INVALID_CATEGORY") if len(public_description) < 20 or len(public_description) > 800: return self._reject_deposit(owner, amount, "INVALID_DESCRIPTION") if len(last_seen_area) < 4 or len(last_seen_area) > 160: return self._reject_deposit(owner, amount, "INVALID_LAST_SEEN_AREA") if not self._valid_source(reference_url): return self._reject_deposit(owner, amount, "IMMUTABLE_REFERENCE_REQUIRED") if not self._valid_content_commitment(reference_url, reference_commitment): return self._reject_deposit(owner, amount, "REFERENCE_COMMITMENT_MISMATCH") if amount == u256(0): return "REWARD_REQUIRED" bounty_id = self.bounty_count self.bounty_owner[bounty_id] = owner self.bounty_title[bounty_id] = title self.bounty_category[bounty_id] = normalized_category self.bounty_description[bounty_id] = public_description self.bounty_last_seen[bounty_id] = last_seen_area self.bounty_reference_url[bounty_id] = reference_url self.bounty_reference_commitment[bounty_id] = reference_commitment.lower() self.bounty_reference_locked_at[bounty_id] = self._now() self.bounty_reward[bounty_id] = amount self.bounty_status[bounty_id] = "OPEN" self.bounty_active_claim[bounty_id] = u256(0) self.bounty_has_active_claim[bounty_id] = u256(0) self.bounty_paid[bounty_id] = u256(0) self.bounty_refunded[bounty_id] = u256(0) self.total_received = self.total_received + amount self.active_escrow = self.active_escrow + amount self.bounty_count = bounty_id + u256(1) return bounty_id @gl.public.write def submit_claim( self, bounty_id: u256, evidence_url: str, evidence_commitment: str, found_area: str, finder_note: str, handoff_commitment: str, ) -> typing.Any: if bounty_id >= self.bounty_count: raise gl.vm.UserError("BOUNTY_NOT_FOUND") finder = gl.message.sender_address.as_hex.lower() if finder == self.bounty_owner[bounty_id]: raise gl.vm.UserError("OWNER_CANNOT_CLAIM") if self.bounty_status[bounty_id] != "OPEN": raise gl.vm.UserError("BOUNTY_NOT_OPEN") if self.bounty_has_active_claim[bounty_id] != u256(0): raise gl.vm.UserError("ACTIVE_CLAIM_EXISTS") if not self._valid_source(evidence_url): raise gl.vm.UserError("IMMUTABLE_FINDER_EVIDENCE_REQUIRED") if not self._valid_content_commitment(evidence_url, evidence_commitment): raise gl.vm.UserError("EVIDENCE_COMMITMENT_MISMATCH") if len(found_area) < 4 or len(found_area) > 160: raise gl.vm.UserError("INVALID_FOUND_AREA") if len(finder_note) < 20 or len(finder_note) > 800: raise gl.vm.UserError("INVALID_FINDER_NOTE") if not self._valid_handoff_commitment(handoff_commitment): raise gl.vm.UserError("INVALID_HANDOFF_COMMITMENT") claim_id = self.claim_count self.claim_bounty[claim_id] = bounty_id self.claim_finder[claim_id] = finder self.claim_evidence_url[claim_id] = evidence_url self.claim_evidence_commitment[claim_id] = evidence_commitment.lower() locked_at = self._now() self.claim_evidence_locked_at[claim_id] = locked_at self.claim_found_area[claim_id] = found_area self.claim_note[claim_id] = finder_note self.claim_handoff_commitment[claim_id] = handoff_commitment.lower() self.claim_status[claim_id] = "LOCKED" self.claim_verdict[claim_id] = "PENDING" self.claim_reason[claim_id] = "Finder evidence and handoff commitment are locked." # A failed or unavailable jury must not strand the funded reward forever. # The owner may reopen this LOCKED claim after a fixed 48-hour safety window. self.claim_deadline[claim_id] = locked_at + u256(172800) self.claim_review_after[claim_id] = locked_at + u256(21600) self.claim_owner_release[claim_id] = u256(0) self.claim_finder_release[claim_id] = u256(0) self.bounty_active_claim[bounty_id] = claim_id self.bounty_has_active_claim[bounty_id] = u256(1) self.bounty_status[bounty_id] = "CLAIMED" self.claim_count = claim_id + u256(1) return claim_id @gl.public.write def withdraw_claim(self, claim_id: u256) -> str: if claim_id >= self.claim_count: raise gl.vm.UserError("CLAIM_NOT_FOUND") sender = gl.message.sender_address.as_hex.lower() if sender != self.claim_finder[claim_id]: raise gl.vm.UserError("FINDER_ONLY") if self.claim_status[claim_id] != "LOCKED": raise gl.vm.UserError("CLAIM_CANNOT_WITHDRAW") self._reopen_bounty( claim_id, "WITHDRAWN", "Finder withdrew before validator review.", ) return "WITHDRAWN" @gl.public.write def recover_locked_claim(self, claim_id: u256) -> str: if claim_id >= self.claim_count: raise gl.vm.UserError("CLAIM_NOT_FOUND") bounty_id = self.claim_bounty[claim_id] sender = gl.message.sender_address.as_hex.lower() if sender != self.bounty_owner[bounty_id]: raise gl.vm.UserError("OWNER_ONLY") if self.claim_status[claim_id] != "LOCKED": raise gl.vm.UserError("CLAIM_NOT_LOCKED") if self._now() <= self.claim_deadline[claim_id]: raise gl.vm.UserError("LOCKED_RECOVERY_WINDOW_OPEN") self._reopen_bounty( claim_id, "TIMED_OUT", "Validator review did not finish within 48 hours; reward reopened by owner.", ) return "TIMED_OUT" @gl.public.write def evaluate_claim(self, claim_id: u256) -> str: if claim_id >= self.claim_count: raise gl.vm.UserError("CLAIM_NOT_FOUND") sender = gl.message.sender_address.as_hex.lower() if not self._is_claim_party(claim_id, sender): raise gl.vm.UserError("PARTY_ONLY") if self.claim_status[claim_id] != "LOCKED": raise gl.vm.UserError("CLAIM_NOT_REVIEWABLE") bounty_id = self.claim_bounty[claim_id] owner = self.bounty_owner[bounty_id] if sender != owner and self._now() < self.claim_review_after[claim_id]: raise gl.vm.UserError("OWNER_REVIEW_WINDOW_OPEN") title = self.bounty_title[bounty_id] category = self.bounty_category[bounty_id] description = self.bounty_description[bounty_id] last_seen = self.bounty_last_seen[bounty_id] owner_url = self.bounty_reference_url[bounty_id] owner_commitment = self.bounty_reference_commitment[bounty_id] owner_locked_at = self.bounty_reference_locked_at[bounty_id] finder_url = self.claim_evidence_url[claim_id] finder_commitment = self.claim_evidence_commitment[claim_id] finder = self.claim_finder[claim_id] finder_locked_at = self.claim_evidence_locked_at[claim_id] found_area = self.claim_found_area[claim_id] finder_note = self.claim_note[claim_id] def jury_fn() -> str: try: owner_image = gl.nondet.web.render(owner_url, mode="screenshot") finder_image = gl.nondet.web.render(finder_url, mode="screenshot") prompt = f"""You are an independent lost-property identity jury. Compare image 1, the owner's pre-committed reference, with image 2, the finder's later immutable evidence packet. BOUNTY Title: {title} Category: {category} Public identifying description: {description} Last seen area: {last_seen} Owner evidence commitment: {owner_commitment} Owner publisher: {owner} Owner evidence locked at: {owner_locked_at} FINDER CLAIM Found area: {found_area} Finder observation: {finder_note} Finder evidence commitment: {finder_commitment} Finder publisher: {finder} Finder evidence locked at: {finder_locked_at} Evaluate stable identity traits, not image style or background. For pets compare coat pattern, markings, scars, ear shape, collar details, body proportions and other individual traits. For objects compare wear, scratches, hardware, layout, contents and unique identifiers. Location consistency is supporting evidence only. Return exactly one token: MATCH_95_PLUS - same specific item/animal with at least 95% confidence. NO_MATCH - material identity traits conflict. INCONCLUSIVE - images are unreadable, insufficient, contradictory, or confidence is below 95%. Never output MATCH_95_PLUS merely because category, breed, color or model is similar. Return exactly one token: MATCH_95_PLUS, NO_MATCH, or INCONCLUSIVE.""" response = str(gl.nondet.exec_prompt( prompt, images=[owner_image, finder_image], )).strip().upper() if response not in ("MATCH_95_PLUS", "NO_MATCH", "INCONCLUSIVE"): return "INVALID_JURY_OUTPUT" return response except Exception: return "SOURCE_UNAVAILABLE" def validator_fn(leader_result) -> bool: if not isinstance(leader_result, gl.vm.Return): return False leader_verdict = str(leader_result.calldata).strip().upper() if leader_verdict not in ( "MATCH_95_PLUS", "NO_MATCH", "INCONCLUSIVE", ): return False validator_verdict = jury_fn() return validator_verdict == leader_verdict verdict = str( gl.vm.run_nondet_unsafe(jury_fn, validator_fn) ).strip().upper() self.claim_verdict[claim_id] = verdict if verdict == "MATCH_95_PLUS": self.claim_status[claim_id] = "MATCHED" self.claim_reason[claim_id] = "Validators found a 95%+ identity match; physical handoff is required." self.claim_deadline[claim_id] = self._now() + u256(172800) self.bounty_status[bounty_id] = "MATCHED" return "MATCHED" if verdict == "NO_MATCH": self._reopen_bounty( claim_id, "REJECTED", "Validators found material identity conflicts; no payout is authorized.", ) return "REJECTED" self.claim_status[claim_id] = "INCONCLUSIVE" self.claim_reason[claim_id] = "Evidence could not support a 95%+ match; bounded recovery is open." self.claim_deadline[claim_id] = self._now() + u256(172800) self.bounty_status[bounty_id] = "RECOVERY" return "INCONCLUSIVE" @gl.public.write def confirm_handoff(self, claim_id: u256, handoff_digest: str) -> str: if claim_id >= self.claim_count: raise gl.vm.UserError("CLAIM_NOT_FOUND") bounty_id = self.claim_bounty[claim_id] sender = gl.message.sender_address.as_hex.lower() if sender != self.bounty_owner[bounty_id]: raise gl.vm.UserError("OWNER_ONLY") if self.claim_status[claim_id] != "MATCHED": raise gl.vm.UserError("CLAIM_NOT_MATCHED") if handoff_digest.lower() != self.claim_handoff_commitment[claim_id]: raise gl.vm.UserError("HANDOFF_CODE_MISMATCH") amount = self.bounty_reward[bounty_id] if amount == u256(0) or amount > self.balance: raise gl.vm.UserError("REWARD_INVARIANT_BROKEN") finder = self.claim_finder[claim_id] self.bounty_reward[bounty_id] = u256(0) self.active_escrow = self.active_escrow - amount self.total_paid = self.total_paid + amount self.bounty_paid[bounty_id] = amount self.bounty_status[bounty_id] = "PAID" self.bounty_has_active_claim[bounty_id] = u256(0) self.claim_status[claim_id] = "PAID" self.claim_reason[claim_id] = "Owner confirmed physical handoff with the committed one-time code." _Recipient(Address(finder)).emit_transfer(value=amount) return "PAID" @gl.public.write def approve_inconclusive_release(self, claim_id: u256) -> str: if claim_id >= self.claim_count: raise gl.vm.UserError("CLAIM_NOT_FOUND") sender = gl.message.sender_address.as_hex.lower() if not self._is_claim_party(claim_id, sender): raise gl.vm.UserError("PARTY_ONLY") if self.claim_status[claim_id] != "INCONCLUSIVE": raise gl.vm.UserError("RELEASE_NOT_AVAILABLE") bounty_id = self.claim_bounty[claim_id] if sender == self.bounty_owner[bounty_id]: if self.claim_owner_release[claim_id] != u256(0): raise gl.vm.UserError("APPROVAL_ALREADY_RECORDED") self.claim_owner_release[claim_id] = u256(1) else: if self.claim_finder_release[claim_id] != u256(0): raise gl.vm.UserError("APPROVAL_ALREADY_RECORDED") self.claim_finder_release[claim_id] = u256(1) if ( self.claim_owner_release[claim_id] != u256(0) and self.claim_finder_release[claim_id] != u256(0) ): self._reopen_bounty( claim_id, "RELEASED", "Both parties released an inconclusive claim; reward remains open.", ) return "RELEASED" return "RELEASE_APPROVAL_RECORDED" @gl.public.write def expire_claim(self, claim_id: u256) -> str: if claim_id >= self.claim_count: raise gl.vm.UserError("CLAIM_NOT_FOUND") sender = gl.message.sender_address.as_hex.lower() if not self._is_claim_party(claim_id, sender): raise gl.vm.UserError("PARTY_ONLY") status = self.claim_status[claim_id] if status != "MATCHED" and status != "INCONCLUSIVE": raise gl.vm.UserError("CLAIM_NOT_EXPIRABLE") if self._now() <= self.claim_deadline[claim_id]: raise gl.vm.UserError("CLAIM_WINDOW_OPEN") self._reopen_bounty( claim_id, "EXPIRED", "The bounded handoff or recovery window expired; reward reopened.", ) return "EXPIRED" @gl.public.write def cancel_reward(self, bounty_id: u256) -> str: if bounty_id >= self.bounty_count: raise gl.vm.UserError("BOUNTY_NOT_FOUND") sender = gl.message.sender_address.as_hex.lower() if sender != self.bounty_owner[bounty_id]: raise gl.vm.UserError("OWNER_ONLY") if self.bounty_status[bounty_id] != "OPEN": raise gl.vm.UserError("BOUNTY_NOT_CANCELLABLE") if self.bounty_has_active_claim[bounty_id] != u256(0): raise gl.vm.UserError("ACTIVE_CLAIM_EXISTS") amount = self.bounty_reward[bounty_id] if amount == u256(0) or amount > self.balance: raise gl.vm.UserError("REWARD_INVARIANT_BROKEN") self.bounty_reward[bounty_id] = u256(0) self.active_escrow = self.active_escrow - amount self.total_refunded = self.total_refunded + amount self.bounty_refunded[bounty_id] = amount self.bounty_status[bounty_id] = "CANCELLED" _Recipient(Address(self.bounty_owner[bounty_id])).emit_transfer(value=amount) return "CANCELLED" @gl.public.view def get_bounty(self, bounty_id: u256) -> str: if bounty_id >= self.bounty_count: return "{}" data = { "id": str(bounty_id), "owner": self.bounty_owner[bounty_id], "title": self.bounty_title[bounty_id], "category": self.bounty_category[bounty_id], "description": self.bounty_description[bounty_id], "last_seen": self.bounty_last_seen[bounty_id], "reference_url": self.bounty_reference_url[bounty_id], "reference_commitment": self.bounty_reference_commitment[bounty_id], "reference_publisher": self.bounty_owner[bounty_id], "reference_locked_at": str(self.bounty_reference_locked_at[bounty_id]), "reward": str(self.bounty_reward[bounty_id]), "status": self.bounty_status[bounty_id], "active_claim": str(self.bounty_active_claim[bounty_id]), "has_active_claim": str(self.bounty_has_active_claim[bounty_id]), "paid": str(self.bounty_paid[bounty_id]), "refunded": str(self.bounty_refunded[bounty_id]), } return json.dumps(data, sort_keys=True, separators=(",", ":")) @gl.public.view def get_claim(self, claim_id: u256) -> str: if claim_id >= self.claim_count: return "{}" data = { "id": str(claim_id), "bounty_id": str(self.claim_bounty[claim_id]), "finder": self.claim_finder[claim_id], "evidence_url": self.claim_evidence_url[claim_id], "evidence_commitment": self.claim_evidence_commitment[claim_id], "evidence_publisher": self.claim_finder[claim_id], "evidence_locked_at": str(self.claim_evidence_locked_at[claim_id]), "found_area": self.claim_found_area[claim_id], "finder_note": self.claim_note[claim_id], "handoff_commitment": self.claim_handoff_commitment[claim_id], "status": self.claim_status[claim_id], "verdict": self.claim_verdict[claim_id], "reason": self.claim_reason[claim_id], "deadline": str(self.claim_deadline[claim_id]), "review_after": str(self.claim_review_after[claim_id]), "owner_release": str(self.claim_owner_release[claim_id]), "finder_release": str(self.claim_finder_release[claim_id]), } return json.dumps(data, sort_keys=True, separators=(",", ":")) @gl.public.view def get_stats(self) -> str: data = { "bounty_count": str(self.bounty_count), "claim_count": str(self.claim_count), "total_received": str(self.total_received), "active_escrow": str(self.active_escrow), "total_paid": str(self.total_paid), "total_refunded": str(self.total_refunded), } return json.dumps(data, sort_keys=True, separators=(",", ":"))