# v0.2.17 # { "Depends": "py-genlayer:1jb45aa8ynh2a9c9xn3b7qqh8sm5q93hwfp7jqmwsfhh8jpz09h6" } from genlayer import * from datetime import datetime, timezone import json @gl.evm.contract_interface class _NativeRecipient: class View: pass class Write: pass class VerdiktParimutuel(gl.Contract): """ VERDIKT — GEN-native parimutuel prediction market. Storage design: Uses only one TreeMap[u256, str] called `store`. This avoids GenLayer storage assertion errors from multiple TreeMaps and from TreeMaps with string keys. Money movement: - All deposits are native GEN. - GEN values are handled in wei. - 1 GEN = 10^18 wei. - place_bet is payable. - claim sends GEN back using emit_transfer. """ owner: Address market_count: u256 suggestion_count: u256 store: TreeMap[u256, str] fee_bps: u256 protocol_fees: u256 min_stake_wei: u256 min_side_liquidity_wei: u256 def __init__(self) -> None: self.owner = gl.message.sender_address self.market_count = u256(0) self.suggestion_count = u256(0) self.store = TreeMap[u256, str]() # 200 bps = 2% self.fee_bps = u256(200) self.protocol_fees = u256(0) # Small defaults for testing. self.min_stake_wei = u256(1) self.min_side_liquidity_wei = u256(1) # ------------------------------------------------------------------ # # KEY NAMESPACES # ------------------------------------------------------------------ # def _market_key(self, market_id: u256) -> u256: # namespace 0 return u256(int(market_id)) def _suggestion_key(self, suggestion_id: u256) -> u256: # namespace 1: 1 << 254 return u256((1 << 254) + int(suggestion_id)) def _stake_key(self, market_id: u256, side: str, user: str) -> u256: """ namespace 2: 2 << 254 payload: - market_id shifted above address bits - address as uint160 - side bit key = namespace + (market_id << 161) + (address_int << 1) + side_bit """ clean_side = side.strip().upper() side_bit = 0 if clean_side == "A" else 1 addr_int = self._address_to_int(user) payload = (int(market_id) << 161) + (addr_int << 1) + side_bit return u256((2 << 254) + payload) def _claimed_key(self, market_id: u256, user: str) -> u256: """ namespace 3: 3 << 254 payload: - market_id shifted above address bits - address as uint160 """ addr_int = self._address_to_int(user) payload = (int(market_id) << 160) + addr_int return u256((3 << 254) + payload) def _address_to_int(self, user: str) -> int: clean = user.strip() if clean.startswith("0x") or clean.startswith("0X"): clean = clean[2:] if len(clean) > 40: clean = clean[-40:] if len(clean) == 0: return 0 return int(clean, 16) # ------------------------------------------------------------------ # # BASIC STORAGE HELPERS # ------------------------------------------------------------------ # def _has_record(self, key: u256) -> bool: return key in self.store def _get_record(self, key: u256) -> str: return self.store[key] def _set_record(self, key: u256, value: str) -> None: self.store[key] = value # ------------------------------------------------------------------ # # INTERNAL HELPERS # ------------------------------------------------------------------ # def _require_owner(self) -> None: if gl.message.sender_address != self.owner: raise gl.vm.UserError("only_owner") def _now(self) -> int: return int(datetime.now(timezone.utc).timestamp()) def _load_market(self, market_id: u256) -> dict: key = self._market_key(market_id) if key not in self.store: raise gl.vm.UserError("market_not_found") return json.loads(self.store[key]) def _save_market(self, market_id: u256, data: dict) -> None: key = self._market_key(market_id) self.store[key] = json.dumps(data) def _load_suggestion(self, suggestion_id: u256) -> dict: key = self._suggestion_key(suggestion_id) if key not in self.store: raise gl.vm.UserError("suggestion_not_found") return json.loads(self.store[key]) def _save_suggestion(self, suggestion_id: u256, data: dict) -> None: key = self._suggestion_key(suggestion_id) self.store[key] = json.dumps(data) def _get_stake_int(self, market_id: u256, side: str, user: str) -> int: key = self._stake_key(market_id, side, user) if key not in self.store: return 0 try: return int(self.store[key]) except Exception: return 0 def _set_stake_int(self, market_id: u256, side: str, user: str, amount: int) -> None: key = self._stake_key(market_id, side, user) self.store[key] = str(amount) def _is_claimed(self, market_id: u256, user: str) -> bool: key = self._claimed_key(market_id, user) if key not in self.store: return False return self.store[key] == "1" def _set_claimed(self, market_id: u256, user: str) -> None: key = self._claimed_key(market_id, user) self.store[key] = "1" def _validate_market_inputs( self, title: str, side_a: str, side_b: str, resolution_rule: str, close_ts: u256, ) -> None: if len(title.strip()) < 5: raise gl.vm.UserError("title_too_short") if len(side_a.strip()) < 1 or len(side_b.strip()) < 1: raise gl.vm.UserError("invalid_sides") if side_a.strip() == side_b.strip(): raise gl.vm.UserError("duplicate_sides") if len(resolution_rule.strip()) < 10: raise gl.vm.UserError("resolution_rule_too_short") if int(close_ts) <= self._now(): raise gl.vm.UserError("close_time_must_be_future") def _refresh_liquidity_status(self, market: dict) -> dict: if market.get("status") not in ["PENDING_LIQUIDITY", "ACTIVE"]: return market pool_a = int(market.get("pool_a", 0)) pool_b = int(market.get("pool_b", 0)) min_side = int(self.min_side_liquidity_wei) if pool_a >= min_side and pool_b >= min_side: market["status"] = "ACTIVE" else: market["status"] = "PENDING_LIQUIDITY" return market def _send_gen(self, recipient: str, amount: u256) -> None: if int(amount) <= 0: return _NativeRecipient(Address(recipient)).emit_transfer(value=amount) def _create_market_internal( self, title: str, side_a: str, side_b: str, resolution_rule: str, resolution_sources: str, close_ts: u256, creator: str, source_type: str, suggestion_id: u256, ) -> u256: self._validate_market_inputs(title, side_a, side_b, resolution_rule, close_ts) market_id = self.market_count market = { "id": int(market_id), "title": title.strip(), "side_a": side_a.strip(), "side_b": side_b.strip(), "resolution_rule": resolution_rule.strip(), "resolution_sources": resolution_sources, "creator": creator, "source_type": source_type, "suggestion_id": int(suggestion_id), "created_ts": self._now(), "close_ts": int(close_ts), "status": "PENDING_LIQUIDITY", "pool_a": 0, "pool_b": 0, "total_pool": 0, "winner": "", "resolved_by": "", "resolved_ts": 0, "resolution_note": "", "fee_bps": int(self.fee_bps), "fee_collected": 0, } self._save_market(market_id, market) self.market_count = u256(int(self.market_count) + 1) return market_id # ------------------------------------------------------------------ # # READ METHODS # ------------------------------------------------------------------ # @gl.public.view def get_owner(self) -> Address: return self.owner @gl.public.view def get_market_count(self) -> u256: return self.market_count @gl.public.view def get_suggestion_count(self) -> u256: return self.suggestion_count @gl.public.view def get_market(self, market_id: u256) -> str: key = self._market_key(market_id) if key not in self.store: return json.dumps({"status": "NOT_FOUND"}) return self.store[key] @gl.public.view def get_suggestion(self, suggestion_id: u256) -> str: key = self._suggestion_key(suggestion_id) if key not in self.store: return json.dumps({"status": "NOT_FOUND"}) return self.store[key] @gl.public.view def get_user_position(self, market_id: u256, user: str) -> str: key = self._market_key(market_id) if key not in self.store: return json.dumps({"status": "MARKET_NOT_FOUND"}) stake_a = self._get_stake_int(market_id, "A", user) stake_b = self._get_stake_int(market_id, "B", user) return json.dumps({ "market_id": int(market_id), "user": user, "stake_a": stake_a, "stake_b": stake_b, "claimed": self._is_claimed(market_id, user), }) @gl.public.view def quote_payout(self, market_id: u256, user: str) -> str: key = self._market_key(market_id) if key not in self.store: return json.dumps({"status": "MARKET_NOT_FOUND"}) market = json.loads(self.store[key]) status = market.get("status") stake_a = self._get_stake_int(market_id, "A", user) stake_b = self._get_stake_int(market_id, "B", user) if self._is_claimed(market_id, user): return json.dumps({ "status": status, "claimable": 0, "reason": "already_claimed", }) if status == "CANCELLED" or market.get("winner") == "VOID": return json.dumps({ "status": status, "claimable": stake_a + stake_b, "reason": "refund", }) if status != "RESOLVED": return json.dumps({ "status": status, "claimable": 0, "reason": "not_claimable_yet", }) winner = market.get("winner") pool_a = int(market.get("pool_a", 0)) pool_b = int(market.get("pool_b", 0)) fee_bps = int(market.get("fee_bps", 0)) if winner == "A": winning_stake = stake_a winning_pool = pool_a losing_pool = pool_b elif winner == "B": winning_stake = stake_b winning_pool = pool_b losing_pool = pool_a else: return json.dumps({ "status": status, "claimable": 0, "reason": "invalid_winner", }) if winning_stake <= 0 or winning_pool <= 0: return json.dumps({ "status": status, "claimable": 0, "reason": "no_winning_position", }) fee = (losing_pool * fee_bps) // 10000 distributable_losing_pool = losing_pool - fee profit = (winning_stake * distributable_losing_pool) // winning_pool payout = winning_stake + profit return json.dumps({ "status": status, "claimable": payout, "reason": "winner_payout", "winning_stake": winning_stake, "profit": profit, "fee_pool": fee, }) @gl.public.view def get_config(self) -> str: return json.dumps({ "owner": str(self.owner), "fee_bps": int(self.fee_bps), "protocol_fees": int(self.protocol_fees), "min_stake_wei": int(self.min_stake_wei), "min_side_liquidity_wei": int(self.min_side_liquidity_wei), }) # ------------------------------------------------------------------ # # ADMIN METHODS # ------------------------------------------------------------------ # @gl.public.write def transfer_ownership(self, new_owner: str) -> None: self._require_owner() if len(new_owner.strip()) < 10: raise gl.vm.UserError("invalid_owner") self.owner = Address(new_owner.strip()) @gl.public.write def set_config( self, fee_bps: u256, min_stake_wei: u256, min_side_liquidity_wei: u256, ) -> None: self._require_owner() if int(fee_bps) > 1000: raise gl.vm.UserError("fee_too_high") if int(min_stake_wei) < 1: raise gl.vm.UserError("min_stake_too_low") if int(min_side_liquidity_wei) < 1: raise gl.vm.UserError("min_side_liquidity_too_low") self.fee_bps = fee_bps self.min_stake_wei = min_stake_wei self.min_side_liquidity_wei = min_side_liquidity_wei @gl.public.write def create_market( self, title: str, side_a: str, side_b: str, resolution_rule: str, resolution_sources: str, close_ts: u256, ) -> u256: self._require_owner() return self._create_market_internal( title, side_a, side_b, resolution_rule, resolution_sources, close_ts, str(gl.message.sender_address), "ADMIN", u256(0), ) @gl.public.write def approve_suggestion(self, suggestion_id: u256) -> u256: self._require_owner() suggestion = self._load_suggestion(suggestion_id) if suggestion.get("status") != "SUGGESTED": raise gl.vm.UserError("suggestion_not_pending") market_id = self._create_market_internal( suggestion.get("title", ""), suggestion.get("side_a", ""), suggestion.get("side_b", ""), suggestion.get("resolution_rule", ""), suggestion.get("resolution_sources", ""), u256(int(suggestion.get("close_ts", 0))), suggestion.get("suggested_by", ""), "SUGGESTION", suggestion_id, ) suggestion["status"] = "APPROVED" suggestion["approved_market_id"] = int(market_id) suggestion["reviewed_by"] = str(gl.message.sender_address) suggestion["reviewed_ts"] = self._now() self._save_suggestion(suggestion_id, suggestion) return market_id @gl.public.write def reject_suggestion(self, suggestion_id: u256, reason: str) -> None: self._require_owner() suggestion = self._load_suggestion(suggestion_id) if suggestion.get("status") != "SUGGESTED": raise gl.vm.UserError("suggestion_not_pending") suggestion["status"] = "REJECTED" suggestion["rejection_reason"] = reason.strip() suggestion["reviewed_by"] = str(gl.message.sender_address) suggestion["reviewed_ts"] = self._now() self._save_suggestion(suggestion_id, suggestion) @gl.public.write def cancel_market(self, market_id: u256, reason: str) -> None: self._require_owner() market = self._load_market(market_id) if market.get("status") in ["RESOLVED", "CANCELLED"]: raise gl.vm.UserError("market_already_final") market["status"] = "CANCELLED" market["winner"] = "VOID" market["resolution_note"] = reason.strip() market["resolved_by"] = str(gl.message.sender_address) market["resolved_ts"] = self._now() self._save_market(market_id, market) @gl.public.write def resolve_market(self, market_id: u256, winner: str, resolution_note: str) -> None: self._require_owner() market = self._load_market(market_id) if market.get("status") in ["RESOLVED", "CANCELLED"]: raise gl.vm.UserError("market_already_final") now = self._now() if now < int(market.get("close_ts", 0)): raise gl.vm.UserError("market_not_closed_yet") pool_a = int(market.get("pool_a", 0)) pool_b = int(market.get("pool_b", 0)) min_side = int(self.min_side_liquidity_wei) if pool_a < min_side or pool_b < min_side: market["status"] = "CANCELLED" market["winner"] = "VOID" market["resolution_note"] = "Cancelled: insufficient two-sided liquidity. " + resolution_note.strip() market["resolved_by"] = str(gl.message.sender_address) market["resolved_ts"] = now self._save_market(market_id, market) return clean_winner = winner.strip().upper() if clean_winner not in ["A", "B", "VOID"]: raise gl.vm.UserError("invalid_winner") if clean_winner == "VOID": market["status"] = "RESOLVED" market["winner"] = "VOID" market["fee_collected"] = 0 else: losing_pool = pool_b if clean_winner == "A" else pool_a fee_bps = int(market.get("fee_bps", 0)) fee = (losing_pool * fee_bps) // 10000 market["status"] = "RESOLVED" market["winner"] = clean_winner market["fee_collected"] = fee self.protocol_fees = u256(int(self.protocol_fees) + fee) market["resolution_note"] = resolution_note.strip() market["resolved_by"] = str(gl.message.sender_address) market["resolved_ts"] = now self._save_market(market_id, market) @gl.public.write def withdraw_protocol_fees(self, recipient: str, amount: u256) -> None: self._require_owner() if int(amount) <= 0: raise gl.vm.UserError("invalid_amount") if int(amount) > int(self.protocol_fees): raise gl.vm.UserError("amount_exceeds_protocol_fees") self.protocol_fees = u256(int(self.protocol_fees) - int(amount)) self._send_gen(recipient.strip(), amount) # ------------------------------------------------------------------ # # USER METHODS # ------------------------------------------------------------------ # @gl.public.write def suggest_market( self, title: str, side_a: str, side_b: str, resolution_rule: str, resolution_sources: str, close_ts: u256, ) -> u256: self._validate_market_inputs(title, side_a, side_b, resolution_rule, close_ts) suggestion_id = self.suggestion_count suggestion = { "id": int(suggestion_id), "title": title.strip(), "side_a": side_a.strip(), "side_b": side_b.strip(), "resolution_rule": resolution_rule.strip(), "resolution_sources": resolution_sources, "close_ts": int(close_ts), "suggested_by": str(gl.message.sender_address), "suggested_ts": self._now(), "status": "SUGGESTED", "approved_market_id": -1, "reviewed_by": "", "reviewed_ts": 0, "rejection_reason": "", } self._save_suggestion(suggestion_id, suggestion) self.suggestion_count = u256(int(self.suggestion_count) + 1) return suggestion_id @gl.public.write.payable def place_bet(self, market_id: u256, side: str) -> None: amount = gl.message.value if int(amount) < int(self.min_stake_wei): raise gl.vm.UserError("stake_below_minimum") market = self._load_market(market_id) status = market.get("status") if status not in ["PENDING_LIQUIDITY", "ACTIVE"]: raise gl.vm.UserError("market_not_open") now = self._now() if now >= int(market.get("close_ts", 0)): raise gl.vm.UserError("market_closed") clean_side = side.strip().upper() if clean_side not in ["A", "B"]: raise gl.vm.UserError("invalid_side") user = str(gl.message.sender_address) previous_stake = self._get_stake_int(market_id, clean_side, user) new_stake = previous_stake + int(amount) self._set_stake_int(market_id, clean_side, user, new_stake) if clean_side == "A": market["pool_a"] = int(market.get("pool_a", 0)) + int(amount) else: market["pool_b"] = int(market.get("pool_b", 0)) + int(amount) market["total_pool"] = int(market.get("pool_a", 0)) + int(market.get("pool_b", 0)) market = self._refresh_liquidity_status(market) self._save_market(market_id, market) @gl.public.write def close_market(self, market_id: u256) -> None: market = self._load_market(market_id) status = market.get("status") if status not in ["PENDING_LIQUIDITY", "ACTIVE"]: raise gl.vm.UserError("market_not_open") now = self._now() if now < int(market.get("close_ts", 0)): raise gl.vm.UserError("market_not_closed_yet") pool_a = int(market.get("pool_a", 0)) pool_b = int(market.get("pool_b", 0)) min_side = int(self.min_side_liquidity_wei) if pool_a < min_side or pool_b < min_side: market["status"] = "CANCELLED" market["winner"] = "VOID" market["resolution_note"] = "Cancelled: insufficient two-sided liquidity." market["resolved_by"] = str(gl.message.sender_address) market["resolved_ts"] = now else: market["status"] = "CLOSED" self._save_market(market_id, market) @gl.public.write def claim(self, market_id: u256) -> u256: market = self._load_market(market_id) user = str(gl.message.sender_address) if self._is_claimed(market_id, user): raise gl.vm.UserError("already_claimed") status = market.get("status") winner = market.get("winner") stake_a = self._get_stake_int(market_id, "A", user) stake_b = self._get_stake_int(market_id, "B", user) if stake_a + stake_b <= 0: raise gl.vm.UserError("no_position") payout = 0 if status == "CANCELLED" or winner == "VOID": payout = stake_a + stake_b elif status == "RESOLVED": pool_a = int(market.get("pool_a", 0)) pool_b = int(market.get("pool_b", 0)) fee_bps = int(market.get("fee_bps", 0)) if winner == "A": winning_stake = stake_a winning_pool = pool_a losing_pool = pool_b elif winner == "B": winning_stake = stake_b winning_pool = pool_b losing_pool = pool_a else: raise gl.vm.UserError("invalid_winner") if winning_stake <= 0: self._set_claimed(market_id, user) return u256(0) if winning_pool <= 0: raise gl.vm.UserError("invalid_winning_pool") fee = (losing_pool * fee_bps) // 10000 distributable_losing_pool = losing_pool - fee profit = (winning_stake * distributable_losing_pool) // winning_pool payout = winning_stake + profit else: raise gl.vm.UserError("market_not_claimable") self._set_claimed(market_id, user) if payout > 0: self._send_gen(user, u256(payout)) return u256(payout) @gl.public.write.payable def __receive__(self) -> None: raise gl.vm.UserError("direct_transfers_not_allowed")