# { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from dataclasses import dataclass from datetime import date, datetime, timedelta from genlayer import * SIDE_TEAM1 = "1" SIDE_TEAM2 = "2" SIDE_DRAW = "0" # Integer forms of the side codes, as returned by the match-result extractor. SIDE_TEAM1_INT = 1 SIDE_TEAM2_INT = 2 SIDE_DRAW_INT = 0 STATUS_OPEN = "OPEN" STATUS_JOINED = "JOINED" STATUS_RESOLVED = "RESOLVED" STATUS_CANCELED = "CANCELED" # After this many days past the match date, either party (or anyone) can # trigger the deterministic expiry refund. This guarantees escrow can never # be locked forever if the result stays unavailable or consensus fails. SETTLEMENT_WINDOW_DAYS = 14 # Platform fee charged on each settled pot, in basis points (200 = 2%). # Accumulated in owner_fees and withdrawable only by the owner. FEE_BPS = 200 # Maximum handicap given to either team, in half-goals (4 halves = 2 goals). # Positive handicaps are given to Team 2, negative to Team 1. HANDICAP_MAX_HALVES = 4 # Only these authoritative football hosts may be used as the match resolution # source. The list is hardcoded so any user can audit it on-chain - no oracle, # no owner-controlled source selection. TRUSTED_SOURCE_HOSTS = { "bbc.com", "www.bbc.com", "bbc.co.uk", "www.bbc.co.uk", "espn.com", "www.espn.com", "skysports.com", "www.skysports.com", "fotmob.com", "www.fotmob.com", "goal.com", "www.goal.com", "theguardian.com", "www.theguardian.com", "uefa.com", "www.uefa.com", "premierleague.com", "www.premierleague.com", } def _trusted_host_of(url: str) -> str: """Extract the lowercase host from a URL without urllib. Keeps URL validation portable across GenVM runtimes (no stdlib reliance). """ rest = url.split("://", 1)[1] if "://" in url else url host = rest.split("/", 1)[0].split(":", 1)[0].strip().lower() return host @gl.evm.contract_interface class _EOARecipient: """EVM-layer interface used to send native value to an EOA. EOAs live on the chain layer, so transfers to them are external messages that go through the contract's ghost contract and always settle on finalization - this is NOT the same as gl.get_contract_at(...).emit_transfer which targets intelligent contracts (triggers __receive__). """ class View: pass class Write: pass @allow_storage @dataclass class Bet: id: str creator: Address opponent: Address game_date: str kickoff_utc: str resolution_url: str team1: str team2: str creator_side: str opponent_side: str handicap_halves: i256 amount: u256 status: str real_winner: str real_score: str winner: Address class BetSettledEvent(gl.Event): def __init__(self, bet_id: str, winner: Address, /, **blob): ... class WithdrawalEvent(gl.Event): def __init__(self, addr: Address, /, **blob): ... class FeesWithdrawnEvent(gl.Event): def __init__(self, addr: Address, /, **blob): ... class P2PGambling(gl.Contract): owner: Address bets: TreeMap[str, Bet] balances: TreeMap[Address, u256] owner_fees: u256 total_escrow: u256 def __init__(self): self.owner = gl.message.sender_address def _verify_fixtures( self, game_date: str, team1: str, team2: str, resolution_url: str, kickoff_utc: str = "", ) -> dict: """Verify teams + kickoff against the real fixtures for the match date. The authoritative source for "are these teams really scheduled" is the BBC scores-fixtures page for the match's actual kickoff date (derived from ``kickoff_utc``, falling back to ``game_date``), NOT the ``resolution_url`` — which may be a live match/blog page that does not list fixtures. Returns a dict: {"valid": bool, "kickoff_verified": bool} - ``valid`` True only if both team names match a real fixture on that date. - ``kickoff_verified`` is only meaningful when ``kickoff_utc`` is supplied. It is True ONLY when the LLM affirmatively confirms the supplied kickoff matches the kickoff shown on the page. It is False (fail-closed) when the page shows no kickoff for the match, the LLM omits ``valid_kickoff``, or the kickoff does not match. A creator must never be able to supply an unverified kickoff. """ # Determine the canonical match date: the match's real kickoff date # (UTC), because BBC buckets fixtures by the kickoff's date. Fall back # to the committed game_date only when no kickoff was supplied. This is # used as the date to confirm the fixture is scheduled on. fixtures_date = game_date if kickoff_utc: try: kickoff_dt = datetime.fromisoformat( kickoff_utc.replace("Z", "+00:00") ) fixtures_date = kickoff_dt.date().isoformat() except (ValueError, TypeError): fixtures_date = game_date def leader_fn(): # The web fetch and the LLM call are both non-deterministic and are # not 100% reliable (occasional empty/bot-blocked pages, or an LLM # that returns malformed/partial JSON). We retry the WHOLE # operation (web render + LLM + evaluate) up to 5 times so a single # transient failure does not fail the whole create_bet. Success is # returned as soon as a fully verified verdict is reached; anything # else retries and only the fail-closed verdict survives all # attempts. (Python retry loops are plain control flow inside the # nondet block; the validator re-runs the same leader_fn.) def attempt() -> dict: web_data = "" for _ in range(3): try: web_data = gl.nondet.web.render( resolution_url, mode="text" ) if web_data and web_data.strip(): break except Exception: web_data = "" if not web_data or not web_data.strip(): return {"valid": False, "kickoff_verified": False} if kickoff_utc: prompt = f"""You are a football fixture verifier. Below is a fixtures/scores page for the date {fixtures_date}. Web content: {web_data} Check if a match between "{team1}" and "{team2}" exists on this page. The team names may appear in different casings or with slight formatting differences (e.g. "Man City" vs "Manchester City"). Be lenient — accept reasonable abbreviations and common short forms. Set valid to FALSE if the match is NOT going to be played on {fixtures_date}, including if it is postponed, abandoned, cancelled, or otherwise removed (e.g. a page that says "Match Postponed" or lists no scheduled kickoff for this fixture). Only set valid to true when the fixture is genuinely scheduled to be played on {fixtures_date}. Separately, the bet creator claims this match kicks off at {kickoff_utc} (UTC). Only set valid_kickoff to true if you can POSITIVELY confirm, from the page, a scheduled kickoff for this match that matches the supplied kickoff within about 90 minutes (converting the page's local/venue timezone to UTC). If the page does not show a kickoff time for this match, or you cannot confirm it matches, set valid_kickoff to false. Respond ONLY with a valid JSON object (no markdown, no code fences, no commentary) with exactly these keys: {{ "valid": true|false, "valid_kickoff": true|false }} """ else: prompt = f"""You are a football fixture verifier. Below is a fixtures/scores page for the date {fixtures_date}. Web content: {web_data} Check if a match between "{team1}" and "{team2}" exists on this page. The team names may appear in different casings or with slight formatting differences (e.g. "Man City" vs "Manchester City"). Be lenient — accept reasonable abbreviations and common short forms. Set valid to FALSE if the match is NOT going to be played on {fixtures_date}, including if it is postponed, abandoned, cancelled, or otherwise removed (e.g. a page that says "Match Postponed" or lists no scheduled kickoff for this fixture). Only set valid to true when the fixture is genuinely scheduled to be played on {fixtures_date}. Respond ONLY with a valid JSON object (no markdown, no code fences, no commentary) with exactly these keys: {{ "valid": true|false }} """ for _ in range(3): try: result = gl.nondet.exec_prompt( prompt, response_format="json" ) valid = bool(result.get("valid", False)) if kickoff_utc: # Fail-closed: kickoff is verified ONLY on # explicit true. A missing valid_kickoff does NOT # verify the kickoff. return { "valid": valid, "kickoff_verified": ( result.get("valid_kickoff") is True ), } return {"valid": valid, "kickoff_verified": False} except Exception: continue return {"valid": False, "kickoff_verified": False} # Up to 5 FULL attempts: return success as soon as a fully # verified verdict is reached. Otherwise retry the whole # operation; after exhausting attempts, fail closed with the LAST # observed verdict so create_bet reports the right reason # (teams-not-found vs kickoff-not-verified). last = {"valid": False, "kickoff_verified": False} for _ in range(5): verdict = attempt() last = verdict if verdict.get("valid"): if not kickoff_utc or verdict.get("kickoff_verified"): return verdict return last def validator_fn(leader_result) -> bool: if not isinstance(leader_result, gl.vm.Return): return False my_result = leader_fn() return leader_result.calldata == my_result return gl.vm.run_nondet_unsafe(leader_fn, validator_fn) def _fetch_match_result( self, resolution_url: str, team1: str, team2: str, match_date: str ) -> dict: """Fetch and validate the FINAL result of the exact wagered match. Returns a dict: {"found": bool, "date": str, "score": str, "winner": int} - ``found`` True only if the page actually contains this match (both team names) with a result. - ``date`` the date the page associates with this match (YYYY-MM-DD). ``resolve_bet`` requires it to equal the canonical ``match_date``, so a wrong-date or missing-date fixture is rejected. - ``score`` the final score "X:Y", or "-" if no result. - ``winner`` 1|2|0|-1 (Team 1, Team 2, draw, or not finished). """ # Resolve against the COMMITTED resolution_url (the source the creator # chose and stored on-chain). This keeps the trust model consistent: the # URL committed at create_bet is the URL that is verified at resolve. # The canonical match_date is used as the date to confirm the result. def leader_fn(): # Web fetch is non-deterministic and occasionally transiently # fails, returning an empty/partial page that makes "found" report # false. Retry the WHOLE operation (render + LLM + evaluate) up to # 5 times so a single hiccup does not abort a resolve; return as # soon as the match is found, otherwise fail closed. def attempt() -> dict: web_data = "" for _ in range(3): try: web_data = gl.nondet.web.render( resolution_url, mode="text" ) if web_data and web_data.strip(): break except Exception: web_data = "" if not web_data or not web_data.strip(): return {"found": False, "date": "", "score": "-", "winner": -1} prompt = f""" You are a match-result extractor. Find the FINAL result of the match between "{team1}" (Team 1) and "{team2}" (Team 2), which was committed for the date {match_date}. Web content: {web_data} Only consider this exact match. If the page does not contain a result for "{team1}" vs "{team2}" played on {match_date}, set found to false (and score, date, winner to unused values). Otherwise set found to true and report: - date: the date of this match exactly as it appears on the page (YYYY-MM-DD) - score: the final score "X:Y" (e.g. "2:1") - winner: 1 if Team 1 won, 2 if Team 2 won, 0 for a draw, -1 if not finished Respond ONLY with a valid JSON object (no markdown, no code fences, no commentary) with exactly these keys: {{ "found": true|false, "date": "YYYY-MM-DD" or "", "score": "X:Y" or "-", "winner": 1|2|0|-1 }} """ for _ in range(3): try: result = gl.nondet.exec_prompt( prompt, response_format="json" ) return { "found": bool(result.get("found", False)), "date": str(result.get("date", "")), "score": str(result.get("score", "-")), "winner": int(result.get("winner", -1)), } except Exception: continue return {"found": False, "date": "", "score": "-", "winner": -1} # Up to 5 FULL attempts: return success as soon as the match is # found; otherwise retry the whole operation and fail closed. for _ in range(5): verdict = attempt() if verdict.get("found"): return verdict return {"found": False, "date": "", "score": "-", "winner": -1} def validator_fn(leader_result) -> bool: if not isinstance(leader_result, gl.vm.Return): return False my_result = leader_fn() leader_data = leader_result.calldata # Every field must match: found, date, score and winner. return ( leader_data.get("found") == my_result.get("found") and leader_data.get("date") == my_result.get("date") and leader_data.get("winner") == my_result.get("winner") and leader_data.get("score") == my_result.get("score") ) return gl.vm.run_nondet_unsafe(leader_fn, validator_fn) def _parse_score(self, score: str): """Parse a final score "X:Y" into (home, away) ints, or None. Strict: exactly two integer parts split on ':' (single spaces around the colon are tolerated). A malformed string returns None so the caller rejects before any payout. """ if not isinstance(score, str): return None parts = score.strip().split(":") if len(parts) != 2: return None s1, s2 = parts[0].strip(), parts[1].strip() if not s1.isdigit() or not s2.isdigit(): return None return int(s1), int(s2) def _handicap_winner(self, s1: int, s2: int, handicap_halves: int) -> str: """Deterministically recompute the winner after applying the handicap. The handicap is stored in half-goals (positive = Team 2 gets the head start, negative = Team 1). Scores are compared in half-goal units so 0.5-goal handicaps stay exact. """ s1_halves = s1 * 2 s2_halves = s2 * 2 + handicap_halves if s1_halves > s2_halves: return SIDE_TEAM1 if s1_halves < s2_halves: return SIDE_TEAM2 return SIDE_DRAW @gl.public.write.payable def deposit(self) -> None: """Add value to the caller's on-chain balance.""" if gl.message.value <= 0: raise gl.vm.UserError("Deposit must be greater than 0") sender = gl.message.sender_address self.balances[sender] = u256(self.balances.get(sender, 0) + gl.message.value) @gl.public.write def withdraw(self, amount: u256) -> None: """Withdraw value from the caller's own balance back to their wallet.""" if amount <= 0: raise gl.vm.UserError("Withdraw amount must be greater than 0") sender = gl.message.sender_address if self.balances.get(sender, 0) < amount: raise gl.vm.UserError("Insufficient balance") self.balances[sender] = u256(self.balances.get(sender, 0) - amount) _EOARecipient(sender).emit_transfer(value=amount) WithdrawalEvent(sender, amount=int(amount)).emit() @gl.public.write def create_bet( self, game_date: str, team1: str, team2: str, side: str, resolution_url: str, amount: u256, handicap_halves: i256 = 0, kickoff_utc: str = "", ) -> None: if side not in (SIDE_TEAM1, SIDE_TEAM2, SIDE_DRAW): raise gl.vm.UserError("Side must be '1', '2', or '0'") if not team1 or not team2 or team1.lower() == team2.lower(): raise gl.vm.UserError("Team names must be distinct and non-empty") if not game_date: raise gl.vm.UserError("Game date is required") if amount <= 0: raise gl.vm.UserError("Bet amount must be greater than 0") if ( handicap_halves < -HANDICAP_MAX_HALVES or handicap_halves > HANDICAP_MAX_HALVES ): raise gl.vm.UserError("Handicap must be between -2 and +2 goals") if side == SIDE_DRAW and handicap_halves != 0: raise gl.vm.UserError("Handicap is only available for team bets") if not ( resolution_url.startswith("http://") or resolution_url.startswith("https://") ): raise gl.vm.UserError("Resolution URL must use a trusted source") if _trusted_host_of(resolution_url) not in TRUSTED_SOURCE_HOSTS: raise gl.vm.UserError("Resolution URL must use a trusted source") # Validate game_date format (YYYY-MM-DD) try: parsed_date = date.fromisoformat(game_date) except (ValueError, TypeError): raise gl.vm.UserError( "Game date must be in YYYY-MM-DD format" ) # Reject bets with past game dates (prevents spam with old/fake dates) try: current_date = date.fromisoformat(gl.message_raw["datetime"][:10]) except (ValueError, TypeError, KeyError): raise gl.vm.UserError("Unable to determine current date") if parsed_date < current_date: raise gl.vm.UserError("Game date must not be in the past") # Validate kickoff_utc (ISO 8601 UTC, e.g. "2026-08-23T19:30:00Z") if kickoff_utc: try: kickoff_dt = datetime.fromisoformat(kickoff_utc.replace("Z", "+00:00")) except (ValueError, TypeError): raise gl.vm.UserError( "Kickoff time must be a valid ISO 8601 UTC timestamp" ) # Bind the kickoff to the committed match date so a bet creator cannot # push the cutoff arbitrarily far into the future, which would keep the # duel joinable after the match has already started/finished. if abs(kickoff_dt.date() - parsed_date) > timedelta(days=1): raise gl.vm.UserError( "Kickoff time must be on or near the match date" ) else: kickoff_dt = None sender = gl.message.sender_address if sender == self.owner: raise gl.vm.UserError("Owner cannot place bets") if self.balances.get(sender, 0) < amount: raise gl.vm.UserError("Insufficient balance") # Verify teams exist in real fixtures for this date (and that the # supplied kickoff matches the fixture when one is provided). verify = self._verify_fixtures( game_date, team1, team2, resolution_url, kickoff_utc ) if not verify.get("valid"): raise gl.vm.UserError( "Teams not found in fixtures for this date" ) # Kickoff integrity (fail-closed): if the creator supplies a kickoff, # it MUST have been affirmatively verified against the fixture. A # kickoff that could not be verified (page shows no kickoff, LLM omits # valid_kickoff, or the timestamps disagree) is rejected outright — we # never store or use a creator-claimed cutoff without source proof. if kickoff_utc and not verify.get("kickoff_verified"): raise gl.vm.UserError( "Kickoff time could not be verified against the fixture" ) stored_kickoff = kickoff_utc bet_id = f"{game_date}_{team1}_{team2}".lower() if bet_id in self.bets and self.bets[bet_id].status in ( STATUS_OPEN, STATUS_JOINED, ): raise gl.vm.UserError("A bet for this match already exists") bet = Bet( id=bet_id, creator=sender, opponent=Address(bytes(20)), game_date=game_date, kickoff_utc=stored_kickoff, resolution_url=resolution_url, team1=team1, team2=team2, creator_side=side, opponent_side="", handicap_halves=handicap_halves, amount=amount, status=STATUS_OPEN, real_winner="", real_score="", winner=Address(bytes(20)), ) self.balances[sender] = u256(self.balances.get(sender, 0) - amount) self.bets[bet_id] = bet self.total_escrow += amount @gl.public.write def join_bet(self, bet_id: str, side: str) -> None: if bet_id not in self.bets: raise gl.vm.UserError("Bet not found") bet = self.bets[bet_id] # --- Match cutoff enforcement --- # 1. Settlement window passed (most specific — must use refund, not re‑join) try: current_date = date.fromisoformat(gl.message_raw["datetime"][:10]) match_date = date.fromisoformat(bet.game_date) except (ValueError, TypeError, KeyError): raise gl.vm.UserError("Unable to determine match timing") if current_date >= match_date + timedelta(days=SETTLEMENT_WINDOW_DAYS): raise gl.vm.UserError("Cannot join bet: settlement window has passed; use refund") # 2. Match kickoff passed (use precise datetime if available, else date-only) if bet.kickoff_utc: try: now_str = gl.message_raw["datetime"] now_utc = datetime.fromisoformat(now_str.replace("Z", "+00:00")) kickoff_dt = datetime.fromisoformat(bet.kickoff_utc.replace("Z", "+00:00")) if now_utc >= kickoff_dt: raise gl.vm.UserError("Cannot join bet: match has already started") except gl.vm.UserError: raise except Exception: # Fallback to date-only comparison if kickoff_utc is malformed if current_date >= match_date: raise gl.vm.UserError("Cannot join bet: match has already started or completed") else: if current_date >= match_date: raise gl.vm.UserError("Cannot join bet: match has already started or completed") # -------------------------------- if bet.status != STATUS_OPEN: raise gl.vm.UserError("Bet is not open") if bet.creator == gl.message.sender_address: raise gl.vm.UserError("Cannot join your own bet") if side not in (SIDE_TEAM1, SIDE_TEAM2, SIDE_DRAW): raise gl.vm.UserError("Side must be '1', '2', or '0'") if side == bet.creator_side: raise gl.vm.UserError("Must bet on the opposite outcome") if self.balances.get(gl.message.sender_address, 0) < bet.amount: raise gl.vm.UserError("Insufficient balance") sender = gl.message.sender_address if sender == self.owner: raise gl.vm.UserError("Owner cannot place bets") self.balances[sender] = u256(self.balances.get(sender, 0) - bet.amount) bet.opponent = sender bet.opponent_side = side bet.status = STATUS_JOINED self.total_escrow += bet.amount @gl.public.write def resolve_bet(self, bet_id: str) -> None: if bet_id not in self.bets: raise gl.vm.UserError("Bet not found") bet = self.bets[bet_id] if bet.status != STATUS_JOINED: raise gl.vm.UserError("Bet must be joined by two players to resolve") # Resolve against the SAME canonical match date used at create time: # the kickoff date (UTC) when available, else the committed game_date. # This keeps resolve consistent with _verify_fixtures (which derives # the fixtures page date from kickoff_utc), so a match whose kickoff # lands on a different date than the viewer's local game_date can still # be resolved instead of falsely rejected as a wrong-date fixture. match_date = bet.game_date if bet.kickoff_utc: try: kd = datetime.fromisoformat( bet.kickoff_utc.replace("Z", "+00:00") ) match_date = kd.date().isoformat() except (ValueError, TypeError): match_date = bet.game_date match_status = self._fetch_match_result( bet.resolution_url, bet.team1, bet.team2, match_date ) # ---- Bind resolution to the exact wagered fixture ---- # The fetched page must actually contain THIS match, ON its canonical # match date. A wrong-date, missing-date, or unrelated fixture must # never settle. if not match_status.get("found"): raise gl.vm.UserError("Match result not found on the resolution page") if match_status.get("date") != match_date: raise gl.vm.UserError("Match result is for a different date than the bet") # ---- Deterministic validation before any payout ---- winner_code = int(match_status.get("winner", -1)) if winner_code == -1: raise gl.vm.UserError("Match not finished") if winner_code not in (SIDE_TEAM1_INT, SIDE_TEAM2_INT, SIDE_DRAW_INT): raise gl.vm.UserError("Invalid winner field") score = self._parse_score(str(match_status.get("score", "-"))) if score is None: raise gl.vm.UserError("Malformed score") s1, s2 = score # The winner field must be consistent with the reported score. A # contradictory result (e.g. score 2:1 but winner 2) is rejected. expected = ( SIDE_TEAM1 if s1 > s2 else SIDE_TEAM2 if s2 > s1 else SIDE_DRAW ) if winner_code != int(expected): raise gl.vm.UserError("Contradictory score and winner") real_winner = expected if bet.handicap_halves != 0: real_winner = self._handicap_winner(s1, s2, bet.handicap_halves) winner_addr = self._determine_winner(bet, real_winner) if winner_addr is None: # Draw result (or no side matched) - refund both, no fee. self._refund_both(bet, real_winner, str(match_status["score"])) else: self._pay_winner( bet, real_winner, str(match_status["score"]), winner_addr ) def _pay_winner( self, bet: Bet, real_winner: str, real_score: str, winner_addr: Address ) -> None: pot = bet.amount * 2 # Round up to at least 1 wei so even tiny pots never bypass the fee. fee = max(pot * FEE_BPS // 10000, 1) payout = pot - fee bet.status = STATUS_RESOLVED bet.real_winner = real_winner bet.real_score = real_score bet.winner = winner_addr self.balances[winner_addr] = u256( self.balances.get(winner_addr, 0) + payout ) self.owner_fees += fee self.total_escrow -= pot BetSettledEvent( bet.id, winner_addr, amount=int(bet.amount), pot=int(pot), fee=int(fee), winner_side=real_winner, score=real_score, ).emit() def _refund_both(self, bet: Bet, reason: str, real_score: str = "") -> None: bet.status = STATUS_RESOLVED bet.real_winner = reason bet.real_score = real_score bet.winner = Address(bytes(20)) self.balances[bet.creator] = u256( self.balances.get(bet.creator, 0) + bet.amount ) self.balances[bet.opponent] = u256( self.balances.get(bet.opponent, 0) + bet.amount ) self.total_escrow -= bet.amount * 2 BetSettledEvent( bet.id, Address(bytes(20)), amount=int(bet.amount), pot=int(bet.amount * 2), fee=0, winner_side=reason, score=real_score, ).emit() def _deadline_passed(self, game_date: str) -> bool: """True when the settlement window (match date + N days) has elapsed.""" try: current = date.fromisoformat(gl.message_raw["datetime"][:10]) match_date = date.fromisoformat(game_date) except (ValueError, TypeError, KeyError): # Fail closed: never unlock early on malformed dates. return False return current >= match_date + timedelta(days=SETTLEMENT_WINDOW_DAYS) @gl.public.write def refund_expired(self, bet_id: str) -> None: """Deterministic escape hatch: after the deadline, settle any unsettled bet. Performs NO web/LLM call, so it can never go undetermined: * A JOINED bet -> both stakes are returned to the players. * An OPEN bet -> no opponent ever joined (and joining is now blocked once the window closes), so the creator's stake is returned and the bet is canceled instead of lingering forever. """ if bet_id not in self.bets: raise gl.vm.UserError("Bet not found") bet = self.bets[bet_id] if bet.status == STATUS_OPEN: if not self._deadline_passed(bet.game_date): raise gl.vm.UserError("Settlement deadline not reached yet") self.balances[bet.creator] = u256( self.balances.get(bet.creator, 0) + bet.amount ) self.total_escrow -= bet.amount bet.status = STATUS_CANCELED bet.real_winner = "REFUND" elif bet.status == STATUS_JOINED: if not self._deadline_passed(bet.game_date): raise gl.vm.UserError("Settlement deadline not reached yet") self._refund_both(bet, "REFUND") else: raise gl.vm.UserError("Bet must be open or joined by two players") @gl.public.write def withdraw_fees(self) -> None: """Owner-only: withdraw the accumulated platform fees. Only the owner can call this, and it moves only ``owner_fees`` (the aggregate fees collected from settled duels). User balances and active escrow are never touched. """ if gl.message.sender_address != self.owner: raise gl.vm.UserError("Only the contract owner can withdraw fees") if self.owner_fees <= 0: raise gl.vm.UserError("No fees to withdraw") amount = self.owner_fees self.owner_fees = 0 _EOARecipient(self.owner).emit_transfer(value=amount) FeesWithdrawnEvent(self.owner, amount=int(amount)).emit() @gl.public.write def cancel_bet(self, bet_id: str) -> None: if bet_id not in self.bets: raise gl.vm.UserError("Bet not found") bet = self.bets[bet_id] if bet.status != STATUS_OPEN: raise gl.vm.UserError("Only open bets can be canceled") if bet.creator != gl.message.sender_address: raise gl.vm.UserError("Only the creator can cancel the bet") bet.status = STATUS_CANCELED self.balances[bet.creator] = u256( self.balances.get(bet.creator, 0) + bet.amount ) self.total_escrow -= bet.amount def _determine_winner(self, bet: Bet, real_winner: str): if real_winner == SIDE_DRAW: if bet.creator_side == SIDE_DRAW: return bet.creator if bet.opponent_side == SIDE_DRAW: return bet.opponent return None if bet.creator_side == real_winner: return bet.creator if bet.opponent_side == real_winner: return bet.opponent return None @gl.public.view def get_balance(self, addr: str) -> int: return int(self.balances.get(Address(addr), 0)) @gl.public.view def get_owner_fees(self) -> int: return int(self.owner_fees) @gl.public.view def get_bet(self, bet_id: str) -> dict: if bet_id not in self.bets: raise gl.vm.UserError("Bet not found") bet = self.bets[bet_id] return { "id": bet.id, "creator": bet.creator.as_hex, "opponent": bet.opponent.as_hex, "game_date": bet.game_date, "kickoff_utc": bet.kickoff_utc, "resolution_url": bet.resolution_url, "team1": bet.team1, "team2": bet.team2, "creator_side": bet.creator_side, "opponent_side": bet.opponent_side, "handicap_halves": int(bet.handicap_halves), "amount": int(bet.amount), "status": bet.status, "real_winner": bet.real_winner, "real_score": bet.real_score, "winner": bet.winner.as_hex, } @gl.public.view def get_bets(self) -> dict: return {bet_id: self.get_bet(bet_id) for bet_id in self.bets} @gl.public.view def get_total_escrow(self) -> int: return int(self.total_escrow) @gl.public.view def get_owner(self) -> str: return self.owner.as_hex