# v0.3.0 # { "Depends": "py-genlayer:5jycge4q8k23462jtb0b9fyey1s9qz928sz2nbrd9mg4sxqg2qng" } import genlayer as gl from genlayer.types import * import json from datetime import datetime, timezone @gl.evm.contract_interface class _Recipient: class View: pass class Write: pass class DuelMarket(gl.contract.Contract): admin: str treasury: str protocol_fee_bps: u256 appeal_window_ms: u256 bet_counter: u256 position_counter: u256 bets_json: str positions_json: str lookup_json: str bet_positions_json: str appeal_json: str def __init__(self): self.admin = str(gl.message.sender_address) self.treasury = str(gl.message.sender_address) self.protocol_fee_bps = u256(200) # 2% default, admin can change self.appeal_window_ms = u256(86400000) # 24h default, admin can change self.bet_counter = u256(0) self.position_counter = u256(0) self.bets_json = "{}" self.positions_json = "{}" self.lookup_json = "{}" self.bet_positions_json = "{}" self.appeal_json = "{}" # --------------------------------------------------------------------- # load / save helpers, same pattern as SportsReferee # --------------------------------------------------------------------- def _load(self, blob: str) -> dict: try: data = json.loads(blob or "{}") return data if isinstance(data, dict) else {} except Exception: return {} def _save_bets(self, data: dict) -> None: self.bets_json = json.dumps(data, sort_keys=True) def _save_positions(self, data: dict) -> None: self.positions_json = json.dumps(data, sort_keys=True) def _save_lookup(self, data: dict) -> None: self.lookup_json = json.dumps(data, sort_keys=True) def _save_bet_positions(self, data: dict) -> None: self.bet_positions_json = json.dumps(data, sort_keys=True) def _save_appeal(self, data: dict) -> None: self.appeal_json = json.dumps(data, sort_keys=True) def _only_admin(self) -> None: if str(gl.message.sender_address) != self.admin: raise gl.vm.UserError("Only admin") def _position_key(self, bet_id: str, wallet: str) -> str: return bet_id + "|" + wallet def _empty_bet(self) -> dict: return { "bet_id": "", "creator": "", "market_type": "clean", "question": "", "side_a_label": "", "side_b_label": "", "evidence_url": "", "evidence_url_fallback": "", "json_field_path": "", "comparison": "", "target_value": "", "resolution_criteria": "", "min_stake": 0, "side_a_total": 0, "side_b_total": 0, "status": "open", "winning_side": "", "resolution_reasoning": "", "resolution_value": "", "created_at": "", "resolve_at": 0, "resolved_at": "", "appeal_deadline": 0, } def _empty_position(self) -> dict: return { "position_id": "", "bet_id": "", "backer": "", "side": "", "amount": 0, "claimed": False, "payout_amount": 0, "joined_at": "", } def _open_or_add_position( self, bets: dict, positions: dict, lookup: dict, bet_positions: dict, bet_id: str, wallet: str, side: str, amount_gen: int ) -> str: key = self._position_key(bet_id, wallet) if key in lookup: position_id = lookup[key] existing = positions[position_id] if existing["side"] != side: raise gl.vm.UserError("Cannot back both sides of the same bet") existing["amount"] = int(existing["amount"]) + amount_gen positions[position_id] = existing else: self.position_counter += u256(1) position_id = f"pos_{self.position_counter}" positions[position_id] = { "position_id": position_id, "bet_id": bet_id, "backer": wallet, "side": side, "amount": amount_gen, "claimed": False, "payout_amount": 0, "joined_at": gl.message.raw["datetime"], } lookup[key] = position_id lst = bet_positions.get(bet_id, []) lst.append(position_id) bet_positions[bet_id] = lst if side == "A": bets[bet_id]["side_a_total"] = int(bets[bet_id]["side_a_total"]) + amount_gen else: bets[bet_id]["side_b_total"] = int(bets[bet_id]["side_b_total"]) + amount_gen return position_id def _refund_all_positions(self, positions: dict, bet_positions: dict, bet_id: str) -> None: for pid in bet_positions.get(bet_id, []): pos = positions[pid] if pos["claimed"]: continue pos["claimed"] = True pos["payout_amount"] = pos["amount"] positions[pid] = pos if int(pos["amount"]) > 0: refund_wei = u256(int(pos["amount"])) * u256(10**18) _Recipient(Address(pos["backer"])).emit_transfer(value=refund_wei) def _finalize_resolution(self, bets: dict, bet_id: str, winning_side: str, reasoning: str, observed_value: str) -> None: now = int(datetime.now(timezone.utc).timestamp() * 1000) row = bets[bet_id] row["winning_side"] = winning_side row["resolution_reasoning"] = reasoning[:500] row["resolution_value"] = observed_value row["resolved_at"] = gl.message.raw["datetime"] row["appeal_deadline"] = now + int(self.appeal_window_ms) row["status"] = "pending_appeal" bets[bet_id] = row # --------------------------------------------------------------------- # market creation # --------------------------------------------------------------------- @gl.public.write.payable def create_clean_market( self, question: str, side_a_label: str, side_b_label: str, evidence_url: str, evidence_url_fallback: str, json_field_path: str, comparison: str, target_value: str, creator_side: str, lock_minutes: u256, min_stake: u256 ) -> str: """ Side A wins if the value at json_field_path in the JSON returned by evidence_url satisfies `comparison target_value` (e.g. ">= 70000"). Side B wins otherwise. evidence_url_fallback is tried only if the primary fetch fails, pass "" if you don't have one. """ creator = str(gl.message.sender_address) if len(question) < 10: raise gl.vm.UserError("Question too short") if len(side_a_label) < 1 or len(side_b_label) < 1: raise gl.vm.UserError("Side labels required") if side_a_label == side_b_label: raise gl.vm.UserError("Side labels must be different") if not evidence_url.startswith("http"): raise gl.vm.UserError("Invalid evidence URL") if evidence_url_fallback != "" and not evidence_url_fallback.startswith("http"): raise gl.vm.UserError("Fallback evidence URL must be empty or a valid URL") if len(json_field_path) < 1: raise gl.vm.UserError("JSON field path required") if comparison not in [">", ">=", "<", "<=", "=="]: raise gl.vm.UserError("Invalid comparison operator") try: float(target_value) except ValueError: raise gl.vm.UserError("target_value must be numeric") if creator_side not in ["A", "B"]: raise gl.vm.UserError("creator_side must be 'A' or 'B'") if int(lock_minutes) < 5: raise gl.vm.UserError("Lock time must be at least 5 minutes out") if int(min_stake) < 1: raise gl.vm.UserError("min_stake must be at least 1") if int(gl.message.value) % (10**18) != 0: raise gl.vm.UserError("Stake must be a whole number of GEN") amount_gen = int(gl.message.value) // (10**18) if amount_gen < int(min_stake): raise gl.vm.UserError("Initial stake below min_stake") self.bet_counter += u256(1) bet_id = f"bet_{self.bet_counter}" now = int(datetime.now(timezone.utc).timestamp() * 1000) bets = self._load(self.bets_json) positions = self._load(self.positions_json) lookup = self._load(self.lookup_json) bet_positions = self._load(self.bet_positions_json) row = self._empty_bet() row["bet_id"] = bet_id row["creator"] = creator row["market_type"] = "clean" row["question"] = question row["side_a_label"] = side_a_label row["side_b_label"] = side_b_label row["evidence_url"] = evidence_url row["evidence_url_fallback"] = evidence_url_fallback row["json_field_path"] = json_field_path row["comparison"] = comparison row["target_value"] = target_value row["min_stake"] = int(min_stake) row["created_at"] = gl.message.raw["datetime"] row["resolve_at"] = now + int(lock_minutes) * 60 * 1000 bets[bet_id] = row self._open_or_add_position(bets, positions, lookup, bet_positions, bet_id, creator, creator_side, amount_gen) self._save_bets(bets) self._save_positions(positions) self._save_lookup(lookup) self._save_bet_positions(bet_positions) return bet_id @gl.public.write.payable def create_vibe_market( self, question: str, side_a_label: str, side_b_label: str, evidence_url: str, evidence_url_fallback: str, resolution_criteria: str, creator_side: str, lock_minutes: u256, min_stake: u256 ) -> str: """ The outcome is judged by AI validators from the content fetched at evidence_url against resolution_criteria, immutable once set. """ creator = str(gl.message.sender_address) if len(question) < 10: raise gl.vm.UserError("Question too short") if len(side_a_label) < 1 or len(side_b_label) < 1: raise gl.vm.UserError("Side labels required") if side_a_label == side_b_label: raise gl.vm.UserError("Side labels must be different") if not evidence_url.startswith("http"): raise gl.vm.UserError("Invalid evidence URL") if evidence_url_fallback != "" and not evidence_url_fallback.startswith("http"): raise gl.vm.UserError("Fallback evidence URL must be empty or a valid URL") if len(resolution_criteria) < 10: raise gl.vm.UserError("Resolution criteria too short") if creator_side not in ["A", "B"]: raise gl.vm.UserError("creator_side must be 'A' or 'B'") if int(lock_minutes) < 5: raise gl.vm.UserError("Lock time must be at least 5 minutes out") if int(min_stake) < 1: raise gl.vm.UserError("min_stake must be at least 1") if int(gl.message.value) % (10**18) != 0: raise gl.vm.UserError("Stake must be a whole number of GEN") amount_gen = int(gl.message.value) // (10**18) if amount_gen < int(min_stake): raise gl.vm.UserError("Initial stake below min_stake") self.bet_counter += u256(1) bet_id = f"bet_{self.bet_counter}" now = int(datetime.now(timezone.utc).timestamp() * 1000) bets = self._load(self.bets_json) positions = self._load(self.positions_json) lookup = self._load(self.lookup_json) bet_positions = self._load(self.bet_positions_json) row = self._empty_bet() row["bet_id"] = bet_id row["creator"] = creator row["market_type"] = "vibe" row["question"] = question row["side_a_label"] = side_a_label row["side_b_label"] = side_b_label row["evidence_url"] = evidence_url row["evidence_url_fallback"] = evidence_url_fallback row["resolution_criteria"] = resolution_criteria row["min_stake"] = int(min_stake) row["created_at"] = gl.message.raw["datetime"] row["resolve_at"] = now + int(lock_minutes) * 60 * 1000 bets[bet_id] = row self._open_or_add_position(bets, positions, lookup, bet_positions, bet_id, creator, creator_side, amount_gen) self._save_bets(bets) self._save_positions(positions) self._save_lookup(lookup) self._save_bet_positions(bet_positions) return bet_id # --------------------------------------------------------------------- # joining / cancelling # --------------------------------------------------------------------- @gl.public.write.payable def join_bet(self, bet_id: str, side: str) -> str: wallet = str(gl.message.sender_address) bets = self._load(self.bets_json) if bet_id not in bets: raise gl.vm.UserError("Bet not found") b = bets[bet_id] if b["status"] != "open": raise gl.vm.UserError("Bet is not open for new positions") now = int(datetime.now(timezone.utc).timestamp() * 1000) if now >= int(b["resolve_at"]): raise gl.vm.UserError("Bet has already locked") if side not in ["A", "B"]: raise gl.vm.UserError("side must be 'A' or 'B'") if int(gl.message.value) % (10**18) != 0: raise gl.vm.UserError("Stake must be a whole number of GEN") amount_gen = int(gl.message.value) // (10**18) if amount_gen <= 0: raise gl.vm.UserError("Must send a positive amount of GEN") lookup = self._load(self.lookup_json) key = self._position_key(bet_id, wallet) if key not in lookup and amount_gen < int(b["min_stake"]): raise gl.vm.UserError("Stake below this bet's minimum") positions = self._load(self.positions_json) bet_positions = self._load(self.bet_positions_json) position_id = self._open_or_add_position(bets, positions, lookup, bet_positions, bet_id, wallet, side, amount_gen) self._save_bets(bets) self._save_positions(positions) self._save_lookup(lookup) self._save_bet_positions(bet_positions) return position_id @gl.public.write def cancel_bet(self, bet_id: str) -> None: caller = str(gl.message.sender_address) bets = self._load(self.bets_json) if bet_id not in bets: raise gl.vm.UserError("Bet not found") b = bets[bet_id] if caller != b["creator"] and caller != self.admin: raise gl.vm.UserError("Only the creator or admin can cancel") if b["status"] != "open": raise gl.vm.UserError("Bet is no longer open") if int(b["side_a_total"]) != 0 and int(b["side_b_total"]) != 0: raise gl.vm.UserError("Cannot cancel once both sides have participants") positions = self._load(self.positions_json) bet_positions = self._load(self.bet_positions_json) self._refund_all_positions(positions, bet_positions, bet_id) b["status"] = "cancelled" bets[bet_id] = b self._save_bets(bets) self._save_positions(positions) @gl.public.write def void_unmatched_bet(self, bet_id: str) -> None: bets = self._load(self.bets_json) if bet_id not in bets: raise gl.vm.UserError("Bet not found") b = bets[bet_id] if b["status"] != "open": raise gl.vm.UserError("Bet is not open") now = int(datetime.now(timezone.utc).timestamp() * 1000) if now < int(b["resolve_at"]): raise gl.vm.UserError("Bet has not reached its lock time yet") if int(b["side_a_total"]) != 0 and int(b["side_b_total"]) != 0: raise gl.vm.UserError("Bet has participants on both sides, call resolve_market instead") positions = self._load(self.positions_json) bet_positions = self._load(self.bet_positions_json) self._refund_all_positions(positions, bet_positions, bet_id) b["status"] = "voided" bets[bet_id] = b self._save_bets(bets) self._save_positions(positions) # --------------------------------------------------------------------- # resolution # --------------------------------------------------------------------- @gl.public.write def resolve_market(self, bet_id: str) -> None: bets = self._load(self.bets_json) if bet_id not in bets: raise gl.vm.UserError("Bet not found") b = bets[bet_id] if b["status"] != "open": raise gl.vm.UserError("Bet is not open") now = int(datetime.now(timezone.utc).timestamp() * 1000) if now < int(b["resolve_at"]): raise gl.vm.UserError("Bet has not reached its lock time yet") if int(b["side_a_total"]) <= 0 or int(b["side_b_total"]) <= 0: raise gl.vm.UserError("Both sides need participants before resolving, call void_unmatched_bet instead") if b["market_type"] == "clean": self._resolve_clean(bets, bet_id) else: self._resolve_vibe(bets, bet_id) self._save_bets(bets) def _resolve_clean(self, bets: dict, bet_id: str) -> None: b = bets[bet_id] primary = b["evidence_url"] fallback = b["evidence_url_fallback"] field_path = b["json_field_path"] op = b["comparison"] target_str = b["target_value"] def fetch_and_evaluate() -> str: def extract_path(data, path): node = data for part in path.split("."): if isinstance(node, dict) and part in node: node = node[part] else: raise KeyError(part) return float(node) def compare(observed, target, operator): if operator == ">": return observed > target elif operator == ">=": return observed >= target elif operator == "<": return observed < target elif operator == "<=": return observed <= target elif operator == "==": return observed == target else: raise ValueError("bad operator") urls_to_try = [primary] if fallback.startswith("http"): urls_to_try.append(fallback) for url in urls_to_try: try: raw = gl.nondet.web.render(url, mode="text") data = json.loads(raw) observed = extract_path(data, field_path) target = float(target_str) condition_true = compare(observed, target, op) winning_side = "A" if condition_true else "B" observed_rounded = round(observed, 6) return json.dumps({ "winning_side": winning_side, "observed_value": str(observed_rounded), "status": "ok" }, sort_keys=True, separators=(',', ':')) except Exception: continue return json.dumps({ "winning_side": "void", "observed_value": "", "status": "fetch_failed" }, sort_keys=True, separators=(',', ':')) consensus_json = gl.eq_principle.strict_eq(fetch_and_evaluate) parsed = json.loads(consensus_json) winning_side = str(parsed.get("winning_side", "void")) if winning_side not in ["A", "B", "void"]: winning_side = "void" observed_value = str(parsed.get("observed_value", "")) status_note = str(parsed.get("status", "")) reasoning = ( f"Resolved from {primary} using field '{field_path}' {op} {target_str}. " f"Observed: {observed_value}. status={status_note}" ) self._finalize_resolution(bets, bet_id, winning_side, reasoning, observed_value) def _resolve_vibe(self, bets: dict, bet_id: str) -> None: b = bets[bet_id] primary = b["evidence_url"] fallback = b["evidence_url_fallback"] question = b["question"] side_a = b["side_a_label"] side_b = b["side_b_label"] criteria = b["resolution_criteria"] def fetch_and_judge() -> str: urls_to_try = [primary] if fallback.startswith("http"): urls_to_try.append(fallback) body_text = "" fetched_url = "" fetched_ok = False for url in urls_to_try: try: text = gl.nondet.web.render(url, mode="text") if text and len(text) > 0: body_text = text[:4000] fetched_url = url fetched_ok = True break except Exception: continue if not fetched_ok: return json.dumps({ "winning_side": "void", "reasoning": "Could not fetch evidence from primary or fallback source" }, sort_keys=True, separators=(',', ':')) prompt = f"""You are settling a peer-to-peer prediction bet between two people. Question: {question} Side A is "{side_a}" Side B is "{side_b}" Resolution criteria set by the bet creator when the bet was made: {criteria} Evidence fetched from {fetched_url}: --- {body_text} --- Decide which side wins based only on the evidence above, judged against the resolution criteria. If the evidence is insufficient, ambiguous, or does not address the question, return "void" rather than guessing. Return ONLY valid JSON: {{"winning_side":"A","reasoning":"one or two sentences"}} winning_side must be exactly one of: A, B, void """ try: result = gl.nondet.exec_prompt(prompt).strip() cleaned = result.replace("```json", "").replace("```", "").strip() parsed = json.loads(cleaned) verdict = str(parsed.get("winning_side", "void")).strip() if verdict not in ["A", "B", "void"]: verdict = "void" return json.dumps({ "winning_side": verdict, "reasoning": str(parsed.get("reasoning", ""))[:400] }, sort_keys=True, separators=(',', ':')) except Exception: return json.dumps({ "winning_side": "void", "reasoning": "Could not parse model response" }, sort_keys=True, separators=(',', ':')) consensus_json = gl.eq_principle.prompt_non_comparative( fetch_and_judge, task="Determine which side of a peer-to-peer prediction bet wins based on fetched evidence and creator-defined resolution criteria", criteria="Return void if the evidence is missing, ambiguous, or does not clearly support one side over the other. Do not guess." ) try: parsed = json.loads(consensus_json.strip()) winning_side = str(parsed.get("winning_side", "void")) if winning_side not in ["A", "B", "void"]: winning_side = "void" reasoning = str(parsed.get("reasoning", "")) except Exception: winning_side = "void" reasoning = "Vibe market verdict could not be parsed" self._finalize_resolution(bets, bet_id, winning_side, reasoning, "") # --------------------------------------------------------------------- # appeal # --------------------------------------------------------------------- @gl.public.write def dispute_resolution(self, bet_id: str, appeal_context: str) -> None: caller = str(gl.message.sender_address) bets = self._load(self.bets_json) if bet_id not in bets: raise gl.vm.UserError("Bet not found") b = bets[bet_id] if b["status"] != "pending_appeal": raise gl.vm.UserError("Bet not eligible for appeal") now = int(datetime.now(timezone.utc).timestamp() * 1000) if now >= int(b["appeal_deadline"]): raise gl.vm.UserError("Appeal window has closed") appeal_used = self._load(self.appeal_json) if bet_id in appeal_used: raise gl.vm.UserError("This bet has already been appealed once") lookup = self._load(self.lookup_json) key = self._position_key(bet_id, caller) if key not in lookup: raise gl.vm.UserError("Only a participant in this bet can appeal") if len(appeal_context) < 10: raise gl.vm.UserError("Please provide more context for the appeal") appeal_used[bet_id] = True self._save_appeal(appeal_used) primary = b["evidence_url"] fallback = b["evidence_url_fallback"] question = b["question"] side_a = b["side_a_label"] side_b = b["side_b_label"] original_verdict = b["winning_side"] original_reasoning = b["resolution_reasoning"] context = appeal_context criteria = b["resolution_criteria"] if b["market_type"] == "vibe" else \ f"{b['json_field_path']} {b['comparison']} {b['target_value']} (source: {b['evidence_url']})" def review_appeal() -> str: urls_to_try = [primary] if fallback.startswith("http"): urls_to_try.append(fallback) body_text = "" fetched_ok = False for url in urls_to_try: try: text = gl.nondet.web.render(url, mode="text") if text and len(text) > 0: body_text = text[:4000] fetched_ok = True break except Exception: continue evidence_note = body_text if fetched_ok else "Could not re-fetch evidence at appeal time." prompt = f"""You are reviewing an appeal of a resolved peer-to-peer prediction bet. Question: {question} Side A: "{side_a}" Side B: "{side_b}" Resolution basis: {criteria} Original verdict: {original_verdict} Original reasoning: {original_reasoning} Freshly fetched evidence: --- {evidence_note} --- Appellant's context and objection: "{context}" Re-review the case with fresh eyes. Uphold the original verdict if it was correct, or overturn it if the appellant's context and the evidence show it was wrong. Return void only if the matter is genuinely unresolvable. Return ONLY valid JSON: {{"winning_side":"A","reasoning":"2-3 sentences explaining the appeal decision"}} winning_side must be exactly one of: A, B, void """ try: result = gl.nondet.exec_prompt(prompt).strip() cleaned = result.replace("```json", "").replace("```", "").strip() parsed = json.loads(cleaned) verdict = str(parsed.get("winning_side", "void")).strip() if verdict not in ["A", "B", "void"]: verdict = "void" return json.dumps({ "winning_side": verdict, "reasoning": str(parsed.get("reasoning", ""))[:400] }, sort_keys=True, separators=(',', ':')) except Exception: return json.dumps({ "winning_side": "void", "reasoning": "Appeal could not be evaluated" }, sort_keys=True, separators=(',', ':')) consensus_json = gl.eq_principle.prompt_non_comparative( review_appeal, task="Review an appeal of a resolved peer-to-peer prediction bet using fresh evidence and the appellant's context", criteria="Uphold or overturn the original verdict based only on the evidence and the stated resolution basis. Use void only if genuinely unresolvable." ) try: parsed = json.loads(consensus_json.strip()) new_verdict = str(parsed.get("winning_side", "void")) if new_verdict not in ["A", "B", "void"]: new_verdict = "void" appeal_reasoning = str(parsed.get("reasoning", "")) except Exception: new_verdict = "void" appeal_reasoning = "Appeal verdict could not be parsed" b["winning_side"] = new_verdict b["resolution_reasoning"] = ( f"[Appeal] {appeal_reasoning} (original verdict was {original_verdict})" )[:500] b["status"] = "appeal_resolved" bets[bet_id] = b self._save_bets(bets) # --------------------------------------------------------------------- # payout # --------------------------------------------------------------------- @gl.public.write def finalize_payout(self, bet_id: str) -> None: bets = self._load(self.bets_json) if bet_id not in bets: raise gl.vm.UserError("Bet not found") b = bets[bet_id] if b["status"] not in ["pending_appeal", "appeal_resolved"]: raise gl.vm.UserError("Bet not ready for payout") if b["status"] == "pending_appeal": now = int(datetime.now(timezone.utc).timestamp() * 1000) if now < int(b["appeal_deadline"]): raise gl.vm.UserError("Appeal window still open") winning_side = b["winning_side"] if winning_side not in ["A", "B", "void"]: raise gl.vm.UserError("Bet has no valid verdict") positions = self._load(self.positions_json) bet_positions = self._load(self.bet_positions_json) if winning_side == "void": self._refund_all_positions(positions, bet_positions, bet_id) b["status"] = "finalized" bets[bet_id] = b self._save_bets(bets) self._save_positions(positions) return winning_total = int(b["side_a_total"]) if winning_side == "A" else int(b["side_b_total"]) losing_total = int(b["side_b_total"]) if winning_side == "A" else int(b["side_a_total"]) if winning_total <= 0: raise gl.vm.UserError("No winning positions to pay out") fee_amount = (losing_total * int(self.protocol_fee_bps)) // 10000 distributable = losing_total - fee_amount allocated = 0 for pid in bet_positions.get(bet_id, []): pos = positions[pid] if pos["side"] == winning_side: share = (int(pos["amount"]) * distributable) // winning_total payout_amount = int(pos["amount"]) + share allocated += share pos["claimed"] = True pos["payout_amount"] = payout_amount positions[pid] = pos if payout_amount > 0: payout_wei = u256(payout_amount) * u256(10**18) _Recipient(Address(pos["backer"])).emit_transfer(value=payout_wei) else: pos["claimed"] = True pos["payout_amount"] = 0 positions[pid] = pos dust = distributable - allocated treasury_amount = fee_amount + dust if treasury_amount > 0: treasury_wei = u256(treasury_amount) * u256(10**18) _Recipient(Address(self.treasury)).emit_transfer(value=treasury_wei) b["status"] = "finalized" bets[bet_id] = b self._save_bets(bets) self._save_positions(positions) # --------------------------------------------------------------------- # admin # --------------------------------------------------------------------- @gl.public.write def set_protocol_fee(self, new_fee_bps: u256) -> None: self._only_admin() if int(new_fee_bps) < 0 or int(new_fee_bps) > 1000: raise gl.vm.UserError("Fee must be between 0 and 1000 bps (0-10%)") self.protocol_fee_bps = new_fee_bps @gl.public.write def set_treasury(self, new_treasury: str) -> None: self._only_admin() if len(new_treasury) == 0: raise gl.vm.UserError("Invalid treasury address") self.treasury = new_treasury @gl.public.write def set_appeal_window(self, new_window_ms: u256) -> None: self._only_admin() if int(new_window_ms) < 0: raise gl.vm.UserError("appeal_window_ms must be non-negative") self.appeal_window_ms = new_window_ms # --------------------------------------------------------------------- # views # --------------------------------------------------------------------- @gl.public.view def get_bet(self, bet_id: str) -> dict: bets = self._load(self.bets_json) if bet_id not in bets: raise gl.vm.UserError("Bet not found") return bets[bet_id] @gl.public.view def get_all_bets(self) -> list: bets = self._load(self.bets_json) result = [] for n in range(1, int(self.bet_counter) + 1): bet_id = f"bet_{n}" if bet_id in bets: result.append(bets[bet_id]) return result @gl.public.view def get_open_bets(self) -> list: bets = self._load(self.bets_json) now = int(datetime.now(timezone.utc).timestamp() * 1000) result = [] for n in range(1, int(self.bet_counter) + 1): bet_id = f"bet_{n}" if bet_id in bets: b = bets[bet_id] if b["status"] == "open" and now < int(b["resolve_at"]): result.append(b) return result @gl.public.view def get_position(self, position_id: str) -> dict: positions = self._load(self.positions_json) if position_id not in positions: raise gl.vm.UserError("Position not found") return positions[position_id] @gl.public.view def get_bet_positions(self, bet_id: str) -> list: bets = self._load(self.bets_json) if bet_id not in bets: raise gl.vm.UserError("Bet not found") positions = self._load(self.positions_json) bet_positions = self._load(self.bet_positions_json) result = [] for pid in bet_positions.get(bet_id, []): result.append(positions[pid]) return result @gl.public.view def get_wallet_position(self, bet_id: str, wallet: str) -> dict: lookup = self._load(self.lookup_json) key = self._position_key(bet_id, wallet) if key not in lookup: raise gl.vm.UserError("No position found for this wallet on this bet") positions = self._load(self.positions_json) return positions[lookup[key]] @gl.public.view def has_position(self, bet_id: str, wallet: str) -> bool: lookup = self._load(self.lookup_json) key = self._position_key(bet_id, wallet) return key in lookup @gl.public.view def has_been_appealed(self, bet_id: str) -> bool: appeal_used = self._load(self.appeal_json) return bet_id in appeal_used @gl.public.view def get_admin(self) -> str: return self.admin @gl.public.view def get_treasury(self) -> str: return self.treasury @gl.public.view def get_protocol_fee_bps(self) -> u256: return self.protocol_fee_bps @gl.public.view def get_total_bets(self) -> u256: return self.bet_counter @gl.public.view def get_total_positions(self) -> u256: return self.position_counter