# v0.3.0 # { "Depends": "py-genlayer:5jycge4q8k23462jtb0b9fyey1s9qz928sz2nbrd9mg4sxqg2qng" } import json import genlayer as gl from genlayer.contract import Contract from genlayer.storage import TreeMap from genlayer.types import Address, u256 PROTOCOL = "VANTA" VERSION = 1 CHAIN_ID = 61997 UP_DOWN = "UP_DOWN" DOMINANCE = "DOMINANCE" MARKET_TYPES = (UP_DOWN, DOMINANCE) ONE_HOUR = 3600 TWO_HOURS = 7200 DURATIONS = (ONE_HOUR, TWO_HOURS) ASSETS = ("BTC", "ETH", "SOL", "BNB", "XRP", "DOGE") MAJORS = "MAJORS" LARGE_CAP_ALTS = "LARGE_CAP_ALTS" CATEGORIES = (MAJORS, LARGE_CAP_ALTS) CATEGORY_ASSETS = { MAJORS: ("BTC", "ETH", "SOL"), LARGE_CAP_ALTS: ("BNB", "XRP", "DOGE"), } BINANCE = "BINANCE" BITGET = "BITGET" GATE = "GATE" SOURCES = (BINANCE, BITGET, GATE) UP = "UP" DOWN = "DOWN" OUTCOME_NONE = 3 STATE_OPEN = "OPEN" STATE_RETRYABLE = "RETRYABLE" STATE_SETTLED = "SETTLED" STATE_INCONCLUSIVE = "INCONCLUSIVE" SOURCE_VALID = "VALID" SOURCE_TIE = "TIE" SOURCE_UNAVAILABLE = "UNAVAILABLE" REASON_NONE = "" REASON_CONSENSUS = "CONSENSUS" REASON_NO_CONSENSUS = "NO_CONSENSUS" REASON_RETRYABLE = "RETRYABLE" REASON_EXPIRED = "EXPIRED_NO_CONSENSUS" REASON_ZERO_BACKED = "ZERO_BACKED_WINNER" GEN_SCALE = 1_000_000_000_000_000_000 MIN_BET = GEN_SCALE MAX_BET_PER_MARKET = 80 * GEN_SCALE PRICE_SCALE = GEN_SCALE RETURN_SCALE = 1_000_000 SETTLEMENT_RETRY_WINDOW_SECONDS = 7200 MAX_RESPONSE_BYTES = 65_536 MAX_PAGE_SIZE = 50 U256_MAX = (1 << 256) - 1 @gl.evm.contract_interface class _NativeRecipient: class View: pass class Write: pass def _is_u256(value): return isinstance(value, int) and not isinstance(value, bool) and 0 <= value <= U256_MAX def _add(left, right): if not _is_u256(left) or not _is_u256(right) or left > U256_MAX - right: raise gl.vm.UserError("u256 addition overflow") return left + right def _mul(left, right): if not _is_u256(left) or not _is_u256(right) or (right and left > U256_MAX // right): raise gl.vm.UserError("u256 multiplication overflow") return left * right def _mul_div(numerator, multiplier, denominator): if not _is_u256(numerator) or not _is_u256(multiplier) or denominator <= 0 or numerator > denominator: raise gl.vm.UserError("invalid payout arithmetic") quotient = 0 remainder = 0 for bit_index in range(256): bit = (numerator >> (255 - bit_index)) & 1 carry = remainder * 2 + (multiplier if bit else 0) added, remainder = divmod(carry, denominator) quotient = quotient * 2 + added if quotient > U256_MAX: raise gl.vm.UserError("u256 payout overflow") return quotient def _digits(value): if not isinstance(value, str) or value == "": return False for char in value: if char < "0" or char > "9": return False return True def _parse_integer(value): if isinstance(value, bool): return None if isinstance(value, int): return value if 0 <= value <= U256_MAX else None if not isinstance(value, str) or len(value) > 40 or not _digits(value): return None parsed = int(value) return parsed if parsed <= U256_MAX else None def _parse_price(value): if isinstance(value, bool): return None if isinstance(value, int): text = str(value) elif isinstance(value, str): text = value else: return None if not text or len(text) > 60 or text.startswith(("+", "-")) or "e" in text.lower(): return None pieces = text.split(".") if len(pieces) > 2 or not _digits(pieces[0]) or len(pieces[0]) > 38: return None fraction = pieces[1] if len(pieces) == 2 else "" if len(pieces) == 2 and (not fraction or not _digits(fraction) or len(fraction) > 18): return None scaled = int(pieces[0]) * PRICE_SCALE + int((fraction + "0" * 18)[:18]) if scaled <= 0 or scaled > 10**38: return None normalized_fraction = fraction.rstrip("0") normalized = str(int(pieces[0])) if normalized_fraction: normalized += "." + normalized_fraction return scaled, normalized def _return_units(opening, closing): delta = closing - opening if abs(delta) > U256_MAX // (100 * RETURN_SCALE): raise gl.vm.UserError("return arithmetic overflow") numerator = abs(delta) * 100 * RETURN_SCALE rounded = (numerator + opening // 2) // opening return rounded if delta >= 0 else -rounded def _timestamp_seconds(raw): if not isinstance(raw, str): raise gl.vm.UserError("invalid transaction datetime") core = raw[:-1] if raw.endswith("Z") else raw[:-6] if raw.endswith("+00:00") else "" if "." in core: parts = core.split(".") if len(parts) != 2 or not _digits(parts[1]) or len(parts[1]) > 9: raise gl.vm.UserError("invalid transaction datetime") core = parts[0] if len(core) != 19 or core[4] != "-" or core[7] != "-" or core[10] != "T" or core[13] != ":" or core[16] != ":": raise gl.vm.UserError("invalid transaction datetime") fields = (core[0:4], core[5:7], core[8:10], core[11:13], core[14:16], core[17:19]) if not all(_digits(field) for field in fields): raise gl.vm.UserError("invalid transaction datetime") year, month, day, hour, minute, second = (int(field) for field in fields) if year < 1970 or month < 1 or month > 12 or hour > 23 or minute > 59 or second > 59: raise gl.vm.UserError("invalid transaction datetime") leap = year % 4 == 0 and (year % 100 != 0 or year % 400 == 0) month_days = (31, 29 if leap else 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31) if day < 1 or day > month_days[month - 1]: raise gl.vm.UserError("invalid transaction datetime") shifted_year = year - 1 if month <= 2 else year era = shifted_year // 400 year_of_era = shifted_year - era * 400 shifted_month = month + 9 if month <= 2 else month - 3 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 return (era * 146097 + day_of_era - 719468) * 86400 + hour * 3600 + minute * 60 + second def _now(): try: raw = gl.message.raw["datetime"] except Exception: raise gl.vm.UserError("transaction datetime unavailable") return _timestamp_seconds(raw) def _asset_names(market_type, subject): if market_type == UP_DOWN: if subject not in ASSETS: raise gl.vm.UserError("unsupported asset") return (subject,) if market_type == DOMINANCE and subject in CATEGORY_ASSETS: return CATEGORY_ASSETS[subject] raise gl.vm.UserError("unsupported dominance category") def _outcome_names(market_type, subject): return (UP, DOWN) if market_type == UP_DOWN else _asset_names(market_type, subject) def _source_symbol(source, asset): if source == GATE: return "index_" + asset + "_USDT" return asset + "USDT" def _http_json(url): try: response = gl.nondet.web.get(url, headers={"Accept": "application/json"}) status = int(response.status) body = response.body if status != 200 or not isinstance(body, (bytes, bytearray)) or not body or len(body) > MAX_RESPONSE_BYTES: return None return json.loads(bytes(body).decode("utf-8"), parse_int=str, parse_float=str) except Exception: return None def _expected_starts(start, duration): return (start,) if duration == ONE_HOUR else (start, _add(start, ONE_HOUR)) def _parse_binance(payload, expected): if not isinstance(payload, list) or len(payload) != len(expected): return None rows = {} for row in payload: if not isinstance(row, list) or len(row) != 12: return None timestamp = _parse_integer(row[0]) if timestamp is None or timestamp not in expected or timestamp in rows or _parse_integer(row[6]) != timestamp + 3_599_999: return None opening = _parse_price(row[1]) closing = _parse_price(row[4]) if opening is None or closing is None: return None rows[timestamp] = (opening, closing) if any(timestamp not in rows for timestamp in expected): return None return [(timestamp, rows[timestamp][0], rows[timestamp][1]) for timestamp in expected] def _parse_bitget(payload, expected): if not isinstance(payload, dict) or payload.get("code") != "00000" or not isinstance(payload.get("data"), list): return None data = payload["data"] if len(data) != len(expected): return None rows = {} for row in data: if not isinstance(row, list) or len(row) != 7: return None timestamp = _parse_integer(row[0]) if timestamp not in expected or timestamp in rows: return None opening = _parse_price(row[1]) closing = _parse_price(row[4]) if opening is None or closing is None: return None rows[timestamp] = (opening, closing) if any(timestamp not in rows for timestamp in expected): return None return [(timestamp, rows[timestamp][0], rows[timestamp][1]) for timestamp in expected] def _parse_gate(payload, expected): if not isinstance(payload, list) or len(payload) != len(expected): return None rows = {} for row in payload: if not isinstance(row, dict) or len(row) > 10 or "t" not in row or "o" not in row or "c" not in row: return None timestamp = _parse_integer(row["t"]) if timestamp not in expected or timestamp in rows: return None opening = _parse_price(row["o"]) closing = _parse_price(row["c"]) if opening is None or closing is None: return None rows[timestamp] = (opening, closing) if any(timestamp not in rows for timestamp in expected): return None return [(timestamp, rows[timestamp][0], rows[timestamp][1]) for timestamp in expected] def _fetch_candles(source, asset, start, end, duration): start_ms = _mul(start, 1000) end_ms = _mul(end, 1000) count = 1 if duration == ONE_HOUR else 2 expected_seconds = _expected_starts(start, duration) expected_ms = tuple(_mul(timestamp, 1000) for timestamp in expected_seconds) if source == BINANCE: url = "https://fapi.binance.com/fapi/v1/indexPriceKlines?pair=" + asset + "USDT&interval=1h&startTime=" + str(start_ms) + "&endTime=" + str(end_ms - 1) + "&limit=" + str(count) return _parse_binance(_http_json(url), expected_ms) if source == BITGET: url = "https://api.bitget.com/api/v3/market/candles?category=USDT-FUTURES&symbol=" + asset + "USDT&interval=1H&type=index&startTime=" + str(start_ms) + "&endTime=" + str(end_ms - 1) + "&limit=" + str(count) return _parse_bitget(_http_json(url), expected_ms) if source == GATE: url = "https://api.gateio.ws/api/v4/futures/usdt/candlesticks?contract=index_" + asset + "_USDT&interval=1h&from=" + str(start) + "&to=" + str(end - 1) return _parse_gate(_http_json(url), expected_seconds) return None def _empty_asset(asset, source, start, end, duration): return { "asset": asset, "symbol": _source_symbol(source, asset), "market_start": start, "market_end": end, "duration_seconds": duration, "interval": "1h", "expected_candle_timestamps": [str(value if source == GATE else value * 1000) for value in _expected_starts(start, duration)], "candles": [], "start_price": "", "end_price": "", "return_units": 0, "valid": False, } def _unavailable(source, market_type, subject, start, end, duration): return { "source": source, "market_type": market_type, "subject": subject, "market_start": start, "market_end": end, "duration_seconds": duration, "interval": "1h", "source_status": SOURCE_UNAVAILABLE, "source_winner": "", "assets": [_empty_asset(asset, source, start, end, duration) for asset in _asset_names(market_type, subject)], } def _source_result(source, market_type, subject, start, end, duration): rows = [] try: for asset in _asset_names(market_type, subject): candles = _fetch_candles(source, asset, start, end, duration) if candles is None: return _unavailable(source, market_type, subject, start, end, duration) first = candles[0][1] last = candles[-1][2] rows.append({ "asset": asset, "symbol": _source_symbol(source, asset), "market_start": start, "market_end": end, "duration_seconds": duration, "interval": "1h", "expected_candle_timestamps": [str(row[0]) for row in candles], "candles": [{"timestamp": row[0], "open": row[1][1], "close": row[2][1]} for row in candles], "start_price": first[1], "end_price": last[1], "return_units": _return_units(first[0], last[0]), "valid": True, }) except Exception: return _unavailable(source, market_type, subject, start, end, duration) if market_type == UP_DOWN: opening = _parse_price(rows[0]["start_price"]) closing = _parse_price(rows[0]["end_price"]) if opening is None or closing is None: return _unavailable(source, market_type, subject, start, end, duration) first_open, first_close = opening[0], closing[0] if first_close > first_open: winner, status = UP, SOURCE_VALID elif first_close < first_open: winner, status = DOWN, SOURCE_VALID else: winner, status = "", SOURCE_TIE else: best = rows[0]["return_units"] winner = rows[0]["asset"] tied = False for row in rows[1:]: if row["return_units"] > best: best, winner, tied = row["return_units"], row["asset"], False elif row["return_units"] == best: tied = True status = SOURCE_TIE if tied else SOURCE_VALID if tied: winner = "" return { "source": source, "market_type": market_type, "subject": subject, "market_start": start, "market_end": end, "duration_seconds": duration, "interval": "1h", "source_status": status, "source_winner": winner, "assets": rows, } def _asset_evidence_valid(row, source, asset, start, end, duration): if not isinstance(row, dict) or row.get("asset") != asset or row.get("symbol") != _source_symbol(source, asset): return False if row.get("market_start") != start or row.get("market_end") != end or row.get("duration_seconds") != duration or row.get("interval") != "1h": return False expected = [str(value if source == GATE else value * 1000) for value in _expected_starts(start, duration)] if row.get("expected_candle_timestamps") != expected or not isinstance(row.get("valid"), bool): return False if not row["valid"]: return row.get("candles") == [] and row.get("start_price") == "" and row.get("end_price") == "" and row.get("return_units") == 0 candles = row.get("candles") if not isinstance(candles, list) or len(candles) != len(expected): return False for index, candle in enumerate(candles): if not isinstance(candle, dict) or candle.get("timestamp") != int(expected[index]) or set(candle.keys()) != {"timestamp", "open", "close"}: return False opening = _parse_price(candle["open"]) closing = _parse_price(candle["close"]) if opening is None or closing is None or candle["open"] != opening[1] or candle["close"] != closing[1]: return False if row.get("start_price") != candles[0]["open"] or row.get("end_price") != candles[-1]["close"]: return False opening = _parse_price(row["start_price"]) closing = _parse_price(row["end_price"]) return opening is not None and closing is not None and row.get("return_units") == _return_units(opening[0], closing[0]) def _source_valid(result, source, market_type, subject, start, end, duration): if not isinstance(result, dict) or result.get("source") != source or result.get("market_type") != market_type or result.get("subject") != subject or result.get("market_start") != start or result.get("market_end") != end or result.get("duration_seconds") != duration or result.get("interval") != "1h": return False status = result.get("source_status") winner = result.get("source_winner") if status not in (SOURCE_VALID, SOURCE_TIE, SOURCE_UNAVAILABLE) or not isinstance(winner, str): return False assets = _asset_names(market_type, subject) rows = result.get("assets") if not isinstance(rows, list) or len(rows) != len(assets): return False for index, asset in enumerate(assets): if not _asset_evidence_valid(rows[index], source, asset, start, end, duration): return False if status == SOURCE_UNAVAILABLE: return winner == "" and all(not row["valid"] for row in rows) if not all(row["valid"] for row in rows): return False if market_type == UP_DOWN: parsed_opening = _parse_price(rows[0]["start_price"]) parsed_closing = _parse_price(rows[0]["end_price"]) if parsed_opening is None or parsed_closing is None: return False opening, closing = parsed_opening[0], parsed_closing[0] expected_winner = UP if closing > opening else DOWN if closing < opening else "" else: best = rows[0]["return_units"] expected_winner = rows[0]["asset"] tied = False for row in rows[1:]: if row["return_units"] > best: best, expected_winner, tied = row["return_units"], row["asset"], False elif row["return_units"] == best: tied = True if tied: expected_winner = "" return status == (SOURCE_VALID if expected_winner else SOURCE_TIE) and winner == expected_winner def _proposal_key(proposal): return json.dumps(proposal, sort_keys=True, separators=(",", ":"), ensure_ascii=False) def _source_consensus(source, market_type, subject, start, end, duration): def leader_fn(): return _source_result(source, market_type, subject, start, end, duration) def validator_fn(leaders_result): if not isinstance(leaders_result, gl.vm.Return) or not isinstance(leaders_result.calldata, dict): return False leader_result = leaders_result.calldata if not _source_valid(leader_result, source, market_type, subject, start, end, duration): return False validator_result = _source_result(source, market_type, subject, start, end, duration) return _source_valid(validator_result, source, market_type, subject, start, end, duration) and _proposal_key(leader_result) == _proposal_key(validator_result) return gl.vm.run_nondet_default(leader_fn, validator_fn, catch_vm_error=True) def _protocol_winner(results): votes = [result.get("source_winner", "") if result.get("source_status") == SOURCE_VALID else "" for result in results] if len(votes) != 3: return "" if votes[0] and votes[0] == votes[1] or votes[0] and votes[0] == votes[2]: return votes[0] if votes[1] and votes[1] == votes[2]: return votes[1] return "" def _source_consensus_result(source, market_type, subject, start, end, duration): try: result = _source_consensus(source, market_type, subject, start, end, duration) if _source_valid(result, source, market_type, subject, start, end, duration): return result except Exception: pass return _unavailable(source, market_type, subject, start, end, duration) class Vanta(Contract): market_count: u256 market_type: TreeMap[u256, str] market_subject: TreeMap[u256, str] market_start: TreeMap[u256, u256] market_end: TreeMap[u256, u256] market_state: TreeMap[u256, str] market_winner: TreeMap[u256, str] market_reason: TreeMap[u256, str] market_creation_keys: TreeMap[str, u256] market_type_count: TreeMap[str, u256] market_type_index: TreeMap[str, u256] market_pool: TreeMap[u256, u256] outcome_pool: TreeMap[str, u256] market_claimed_pool: TreeMap[u256, u256] market_claimed_winning_stake: TreeMap[u256, u256] market_refunded_pool: TreeMap[u256, u256] market_source_evidence: TreeMap[str, str] bettor_outcome: TreeMap[str, u256] bettor_stake: TreeMap[str, u256] bettor_claimed: TreeMap[str, bool] bettor_refunded: TreeMap[str, bool] user_market_count: TreeMap[str, u256] user_market_index: TreeMap[str, u256] def __init__(self): self.market_count = 0 def _market(self, market_id): if not _is_u256(market_id) or market_id == 0 or market_id > self.market_count or market_id not in self.market_type: raise gl.vm.UserError("market not found") def _position_key(self, market_id, user): return str(market_id) + ":" + user.as_hex def _outcome_key(self, market_id, outcome): return str(market_id) + ":" + str(outcome) def _type_key(self, market_type, index): return market_type + ":" + str(index) def _user_key(self, user): return user.as_hex def _user_index_key(self, user, index): return user.as_hex + ":" + str(index) def _source_key(self, market_id, source): return str(market_id) + ":" + source def _deadline(self, market_id): return _add(self.market_end[market_id], SETTLEMENT_RETRY_WINDOW_SECONDS) def _outcomes(self, market_id): return _outcome_names(self.market_type[market_id], self.market_subject[market_id]) def _pool_view(self, market_id): return {name: self.outcome_pool.get(self._outcome_key(market_id, index), 0) for index, name in enumerate(self._outcomes(market_id))} def _phase(self, market_id, now): state = self.market_state[market_id] if state == STATE_SETTLED: return "SETTLED" if state == STATE_INCONCLUSIVE: return "REFUND" if now >= self._deadline(market_id): return "REFUND" if state == STATE_RETRYABLE: return "RETRYABLE" if now < self.market_start[market_id]: return "PREDICTION_OPEN" if now < self.market_end[market_id]: return "ACTIVE" return "READY_TO_SETTLE" def _market_view(self, market_id, summary=False): self._market(market_id) now = _now() state = self.market_state[market_id] total = self.market_pool.get(market_id, 0) claimed = self.market_claimed_pool.get(market_id, 0) refunded = self.market_refunded_pool.get(market_id, 0) if claimed > total or refunded > total: raise gl.vm.UserError("market liability overflow") consumed = claimed if state == STATE_SETTLED else refunded if state == STATE_INCONCLUSIVE else 0 if consumed > total: raise gl.vm.UserError("market liability overflow") deadline = self._deadline(market_id) phase = self._phase(market_id, now) winner = self.market_winner.get(market_id, "") if summary: return { "id": market_id, "market_type": self.market_type[market_id], "subject": self.market_subject[market_id], "duration_seconds": self.market_end[market_id] - self.market_start[market_id], "market_start": self.market_start[market_id], "market_end": self.market_end[market_id], "state": state, "phase": phase, "resolution": winner, "total_pool": total, "outcome_pools": self._pool_view(market_id), "betting_open": state == STATE_OPEN and now < self.market_start[market_id], "settlement_ready": state not in (STATE_SETTLED, STATE_INCONCLUSIVE) and now >= self.market_end[market_id], "settlement_deadline": deadline, "retry_window_active": state not in (STATE_SETTLED, STATE_INCONCLUSIVE) and self.market_end[market_id] <= now < deadline, "terminal_refund_available": (state == STATE_INCONCLUSIVE and refunded < total) or (state not in (STATE_SETTLED, STATE_INCONCLUSIVE) and now >= deadline), } outcomes = self._outcomes(market_id) return { "id": market_id, "market_type": self.market_type[market_id], "subject": self.market_subject[market_id], "assets": list(_asset_names(self.market_type[market_id], self.market_subject[market_id])), "outcomes": list(outcomes), "duration_seconds": self.market_end[market_id] - self.market_start[market_id], "market_start": self.market_start[market_id], "market_end": self.market_end[market_id], "state": state, "phase": phase, "resolution": winner, "winner": winner, "reason": self.market_reason.get(market_id, REASON_NONE), "betting_open": state == STATE_OPEN and now < self.market_start[market_id], "settlement_available": state not in (STATE_SETTLED, STATE_INCONCLUSIVE) and now >= self.market_end[market_id], "settlement_deadline": deadline, "retry_window_active": state not in (STATE_SETTLED, STATE_INCONCLUSIVE) and self.market_end[market_id] <= now < deadline, "terminal_refund_available": (state == STATE_INCONCLUSIVE and refunded < total) or (state not in (STATE_SETTLED, STATE_INCONCLUSIVE) and now >= deadline), "total_pool": total, "outcome_pools": self._pool_view(market_id), "winning_pool": 0 if not winner else self.outcome_pool.get(self._outcome_key(market_id, outcomes.index(winner)), 0), "claimed_pool": claimed, "refunded_pool": refunded, "remaining_pool": total - consumed, "evidence_available": self._source_key(market_id, BINANCE) in self.market_source_evidence, } def _position_view(self, market_id, user): self._market(market_id) key = self._position_key(market_id, user) selected = self.bettor_outcome.get(key, OUTCOME_NONE) outcomes = self._outcomes(market_id) has_position = selected < len(outcomes) stake = self.bettor_stake.get(key, 0) state = self.market_state[market_id] claimed = self.bettor_claimed.get(key, False) refunded = self.bettor_refunded.get(key, False) winner = self.market_winner.get(market_id, "") claimable = 0 claim_type = "NONE" position_result = "NONE" if state == STATE_SETTLED and has_position: if outcomes[selected] == winner: position_result = "WIN" winning_pool = self.outcome_pool.get(self._outcome_key(market_id, selected), 0) claimed_pool = self.market_claimed_pool.get(market_id, 0) claimed_stake = self.market_claimed_winning_stake.get(market_id, 0) total = self.market_pool.get(market_id, 0) new_stake = _add(claimed_stake, stake) if not claimed and winning_pool > 0 and new_stake <= winning_pool and claimed_pool <= total: claimable = total - claimed_pool if new_stake == winning_pool else _mul_div(stake, total, winning_pool) if claimable > 0: claim_type = "WINNINGS" else: position_result = "LOSS" if state == STATE_INCONCLUSIVE and has_position: position_result = "REFUND" if not refunded: claimable = stake claim_type = "REFUND" return { "market_id": market_id, "wallet": user.as_hex, "market_type": self.market_type[market_id], "subject": self.market_subject[market_id], "market_start": self.market_start[market_id], "market_end": self.market_end[market_id], "market_state": state, "winner": winner, "has_position": has_position, "selected_outcome": "" if not has_position else outcomes[selected], "stake": stake, "remaining_capacity": 0 if stake >= MAX_BET_PER_MARKET else MAX_BET_PER_MARKET - stake, "can_top_up": state == STATE_OPEN and _now() < self.market_start[market_id] and stake < MAX_BET_PER_MARKET, "result": position_result, "claimable": claimable, "claimable_amount": claimable, "claim_type": claim_type, "claimed": claimed, "refunded": refunded, } def _bounds(self, offset, limit, count): if not _is_u256(offset) or not _is_u256(limit) or limit == 0 or limit > MAX_PAGE_SIZE: raise gl.vm.UserError("page limit must be between 1 and 50") if offset >= count: return offset, offset remaining = count - offset return offset, count if limit >= remaining else _add(offset, limit) def _page(self, items, offset, limit, total, field): end = offset + len(items) return {"offset": offset, "limit": limit, "total": total, "has_more": end < total, "next_offset": end if end < total else 0, field: items} def _send(self, recipient, amount): _NativeRecipient(recipient).emit_transfer(value=amount) # pyright: ignore[reportCallIssue, reportAttributeAccessIssue] @gl.public.view def get_config(self) -> dict: return { "protocol": PROTOCOL, "version": VERSION, "chain_id": CHAIN_ID, "market_types": list(MARKET_TYPES), "durations": {"1H": ONE_HOUR, "2H": TWO_HOURS}, "supported_assets": list(ASSETS), "dominance_categories": list(CATEGORIES), "category_assets": {MAJORS: list(CATEGORY_ASSETS[MAJORS]), LARGE_CAP_ALTS: list(CATEGORY_ASSETS[LARGE_CAP_ALTS])}, "minimum_bet": MIN_BET, "maximum_bet_per_wallet_per_market": MAX_BET_PER_MARKET, "fee_bps": 0, "sources": list(SOURCES), "consensus_threshold": 2, "settlement_retry_window_seconds": SETTLEMENT_RETRY_WINDOW_SECONDS, "timezone": "UTC", "price_precision": PRICE_SCALE, "return_precision": RETURN_SCALE, "payout_rounding_policy": "floor; final winning claimant receives remaining pool", "zero_backed_winner_behavior": "INCONCLUSIVE with original-stake refunds", "max_page_size": MAX_PAGE_SIZE, } @gl.public.view def get_market_count(self) -> u256: return self.market_count @gl.public.view def get_supported_assets(self) -> list[str]: return list(ASSETS) @gl.public.view def get_categories(self) -> list[str]: return list(CATEGORIES) @gl.public.view def category_assets(self, category: str) -> list[str]: if category not in CATEGORY_ASSETS: raise gl.vm.UserError("unsupported dominance category") return list(CATEGORY_ASSETS[category]) @gl.public.view def get_market(self, market_id: u256) -> dict: return self._market_view(market_id) @gl.public.view def get_market_summary(self, market_id: u256) -> dict: return self._market_view(market_id, True) @gl.public.view def get_markets(self, offset: u256, limit: u256) -> dict: start, end = self._bounds(offset, limit, self.market_count) items = [self._market_view(index, True) for index in range(start + 1, end + 1)] return self._page(items, offset, limit, self.market_count, "markets") @gl.public.view def get_markets_by_type(self, market_type: str, offset: u256, limit: u256) -> dict: if market_type not in MARKET_TYPES: raise gl.vm.UserError("unsupported market type") count = self.market_type_count.get(market_type, 0) start, end = self._bounds(offset, limit, count) items = [self._market_view(self.market_type_index[self._type_key(market_type, index)], True) for index in range(start, end)] return self._page(items, offset, limit, count, "markets") @gl.public.view def get_user_market(self, market_id: u256, wallet: Address) -> dict: return self._position_view(market_id, wallet) @gl.public.view def get_remaining_position_capacity(self, market_id: u256, wallet: Address) -> u256: return self._position_view(market_id, wallet)["remaining_capacity"] @gl.public.view def get_user_positions(self, wallet: Address, offset: u256, limit: u256) -> dict: count = self.user_market_count.get(self._user_key(wallet), 0) start, end = self._bounds(offset, limit, count) items = [self._position_view(self.user_market_index[self._user_index_key(wallet, index)], wallet) for index in range(start, end)] return self._page(items, offset, limit, count, "positions") @gl.public.view def get_claimable(self, market_id: u256, wallet: Address) -> u256: return self._position_view(market_id, wallet)["claimable"] @gl.public.view def get_claimable_markets(self, wallet: Address, offset: u256, limit: u256) -> dict: count = self.user_market_count.get(self._user_key(wallet), 0) start, end = self._bounds(offset, limit, count) items = [] for index in range(start, end): position = self._position_view(self.user_market_index[self._user_index_key(wallet, index)], wallet) if position["claimable"] > 0: items.append(position) return { "offset": offset, "limit": limit, "total_positions": count, "has_more": end < count, "next_offset": end if end < count else 0, "claims": items, } @gl.public.view def get_ready_to_settle_markets(self, offset: u256, limit: u256) -> dict: now = _now() start, end = self._bounds(offset, limit, self.market_count) items = [] for market_id in range(start + 1, end + 1): if self.market_state[market_id] not in (STATE_SETTLED, STATE_INCONCLUSIVE) and now >= self.market_end[market_id]: items.append(self._market_view(market_id, True)) return { "offset": offset, "limit": limit, "total_markets": self.market_count, "has_more": end < self.market_count, "next_offset": end if end < self.market_count else 0, "markets": items, } @gl.public.view def get_settlement_evidence(self, market_id: u256) -> dict: self._market(market_id) if self._source_key(market_id, BINANCE) not in self.market_source_evidence: raise gl.vm.UserError("settlement evidence unavailable") sources = [json.loads(self.market_source_evidence[self._source_key(market_id, source)]) for source in SOURCES] return { "market_id": market_id, "market_type": self.market_type[market_id], "subject": self.market_subject[market_id], "market_start": self.market_start[market_id], "market_end": self.market_end[market_id], "duration_seconds": self.market_end[market_id] - self.market_start[market_id], "resolution": self.market_winner.get(market_id, ""), "sources": sources, } @gl.public.write def create_market(self, market_type: str, subject: str, market_start: u256, duration_seconds: u256) -> u256: if market_type not in MARKET_TYPES: raise gl.vm.UserError("unsupported market type") if duration_seconds not in DURATIONS: raise gl.vm.UserError("unsupported duration") if not _is_u256(market_start) or market_start % 3600 != 0: raise gl.vm.UserError("market start must be exact UTC hour") _asset_names(market_type, subject) now = _now() if market_start <= now: raise gl.vm.UserError("market start must be in the future") end = _add(market_start, duration_seconds) _add(end, SETTLEMENT_RETRY_WINDOW_SECONDS) _mul(market_start, 1000) _mul(end, 1000) key = market_type + "|" + subject + "|" + str(market_start) + "|" + str(duration_seconds) if key in self.market_creation_keys: raise gl.vm.UserError("duplicate market") market_id = _add(self.market_count, 1) type_count = self.market_type_count.get(market_type, 0) self.market_count = market_id self.market_type[market_id] = market_type self.market_subject[market_id] = subject self.market_start[market_id] = market_start self.market_end[market_id] = end self.market_state[market_id] = STATE_OPEN self.market_winner[market_id] = "" self.market_reason[market_id] = REASON_NONE self.market_creation_keys[key] = market_id self.market_type_index[self._type_key(market_type, type_count)] = market_id self.market_type_count[market_type] = _add(type_count, 1) self.market_pool[market_id] = 0 self.market_claimed_pool[market_id] = 0 self.market_claimed_winning_stake[market_id] = 0 self.market_refunded_pool[market_id] = 0 return market_id @gl.public.write.payable def place_bet(self, market_id: u256, outcome: str) -> None: self._market(market_id) if self.market_state[market_id] != STATE_OPEN or _now() >= self.market_start[market_id]: raise gl.vm.UserError("betting is closed") outcomes = self._outcomes(market_id) if outcome not in outcomes: raise gl.vm.UserError("invalid outcome") amount = gl.message.value if not _is_u256(amount) or amount < MIN_BET: raise gl.vm.UserError("minimum bet is 1 GEN") key = self._position_key(market_id, gl.message.sender_address) selected = self.bettor_outcome.get(key, OUTCOME_NONE) outcome_id = outcomes.index(outcome) if selected != OUTCOME_NONE and selected != outcome_id: raise gl.vm.UserError("wallet outcome already selected") old_stake = self.bettor_stake.get(key, 0) if old_stake > MAX_BET_PER_MARKET or amount > MAX_BET_PER_MARKET - old_stake: raise gl.vm.UserError("maximum cumulative stake is 80 GEN") if selected == OUTCOME_NONE: user_key = self._user_key(gl.message.sender_address) user_count = self.user_market_count.get(user_key, 0) self.user_market_index[self._user_index_key(gl.message.sender_address, user_count)] = market_id self.user_market_count[user_key] = _add(user_count, 1) new_stake = _add(old_stake, amount) pool_key = self._outcome_key(market_id, outcome_id) self.bettor_outcome[key] = outcome_id self.bettor_stake[key] = new_stake self.outcome_pool[pool_key] = _add(self.outcome_pool.get(pool_key, 0), amount) self.market_pool[market_id] = _add(self.market_pool.get(market_id, 0), amount) @gl.public.write def settle_market(self, market_id: u256) -> str: self._market(market_id) state = self.market_state[market_id] if state in (STATE_SETTLED, STATE_INCONCLUSIVE): raise gl.vm.UserError("market already terminal") now = _now() end = self.market_end[market_id] deadline = self._deadline(market_id) if now < end: raise gl.vm.UserError("market has not ended") if now >= deadline: self.market_state[market_id] = STATE_INCONCLUSIVE self.market_winner[market_id] = "" self.market_reason[market_id] = REASON_EXPIRED return STATE_INCONCLUSIVE market_type = self.market_type[market_id] subject = self.market_subject[market_id] start = self.market_start[market_id] duration = end - start results = [_source_consensus_result(source, market_type, subject, start, end, duration) for source in SOURCES] for index, source in enumerate(SOURCES): self.market_source_evidence[self._source_key(market_id, source)] = json.dumps(results[index], sort_keys=True, separators=(",", ":")) winner = _protocol_winner(results) if not winner: self.market_state[market_id] = STATE_RETRYABLE self.market_winner[market_id] = "" self.market_reason[market_id] = REASON_NO_CONSENSUS return STATE_RETRYABLE winning_id = self._outcomes(market_id).index(winner) winning_pool = self.outcome_pool.get(self._outcome_key(market_id, winning_id), 0) if winning_pool == 0: self.market_state[market_id] = STATE_INCONCLUSIVE self.market_winner[market_id] = "" self.market_reason[market_id] = REASON_ZERO_BACKED return STATE_INCONCLUSIVE self.market_state[market_id] = STATE_SETTLED self.market_winner[market_id] = winner self.market_reason[market_id] = REASON_CONSENSUS return STATE_SETTLED @gl.public.write def claim(self, market_id: u256) -> None: self._market(market_id) if self.market_state[market_id] != STATE_SETTLED: raise gl.vm.UserError("market is not settled") key = self._position_key(market_id, gl.message.sender_address) if self.bettor_claimed.get(key, False) or self.bettor_refunded.get(key, False): raise gl.vm.UserError("position already claimed") selected = self.bettor_outcome.get(key, OUTCOME_NONE) outcomes = self._outcomes(market_id) if selected >= len(outcomes) or outcomes[selected] != self.market_winner[market_id]: raise gl.vm.UserError("not a winning position") stake = self.bettor_stake.get(key, 0) winning_pool = self.outcome_pool.get(self._outcome_key(market_id, selected), 0) total = self.market_pool.get(market_id, 0) claimed = self.market_claimed_pool.get(market_id, 0) claimed_stake = self.market_claimed_winning_stake.get(market_id, 0) new_stake = _add(claimed_stake, stake) if stake == 0 or winning_pool == 0 or new_stake > winning_pool or claimed > total: raise gl.vm.UserError("invalid winning accounting") payout = total - claimed if new_stake == winning_pool else _mul_div(stake, total, winning_pool) if payout == 0 or payout > total - claimed: raise gl.vm.UserError("payout exceeds remaining pool") self.bettor_claimed[key] = True self.market_claimed_pool[market_id] = _add(claimed, payout) self.market_claimed_winning_stake[market_id] = new_stake self._send(gl.message.sender_address, payout) @gl.public.write def claim_refund(self, market_id: u256) -> None: self._market(market_id) if self.market_state[market_id] != STATE_INCONCLUSIVE: raise gl.vm.UserError("market is not inconclusive") key = self._position_key(market_id, gl.message.sender_address) if self.bettor_claimed.get(key, False) or self.bettor_refunded.get(key, False): raise gl.vm.UserError("position already claimed") stake = self.bettor_stake.get(key, 0) total = self.market_pool.get(market_id, 0) refunded = self.market_refunded_pool.get(market_id, 0) if stake == 0 or refunded > total or stake > total - refunded: raise gl.vm.UserError("refund exceeds remaining pool") self.bettor_refunded[key] = True self.market_refunded_pool[market_id] = _add(refunded, stake) self._send(gl.message.sender_address, stake)