# v0.3.0 # { "Depends": "py-genlayer:latest" } # Assay Layer — ConditionalTVLMarket # # One instance per market. Parameters are constructor-frozen (no setters). # LMSR is 18-decimal wad integer math. Fees (150 bps) accrue to fee_sink, never # the creator. resolve_market is uncallable by anyone — resolution is applied # inside request_resolution via gl.eq_principle.strict_eq. on_proposal_finalized # is adapter-only. Creator bond is forfeited ONLY on protocolSlug identity # bait-and-switch (D19), never on proposal-reject Void or source-unavailable Void. # # WHY NONDET: TVL is interpretive. Validators re-fetch the frozen methodology's # DeFiLlama identity + TVL and must agree on the canonical payload. import genlayer as gl from genlayer.types import * import ipaddress import json import re from datetime import datetime, timezone from decimal import Decimal, ROUND_DOWN, ROUND_UP, localcontext WAD = 10**18 FEE_BPS = 150 MAX_BPS = 10000 MAX_APPEALS = 2 MIN_APPEAL_BOND = WAD RETRY_SECONDS = 7 * 86400 YES = 0 NO = 1 _PID_RE = re.compile(r"^[a-zA-Z0-9._:-]{1,128}$") _SLUG_RE = re.compile(r"^[a-z0-9][a-z0-9-]{0,63}$") _ADDR_RE = re.compile(r"^0x[a-fA-F0-9]{40}$") _ZERO = Address("0x" + "00" * 20) _DOH = "https://dns.google/resolve" _CGNAT = ipaddress.ip_network("100.64.0.0/10") _NAT64 = ipaddress.ip_network("64:ff9b::/96") _DROP = ("staking", "pool2", "borrowed", "doublecounted", "vesting", "owntokens", "treasury") _IDENTITY_KEYS = ("id", "name", "gecko_id", "slug") _TERMINAL = ("Void", "ResolvedYes", "ResolvedNo") @gl.evm.contract_interface class _Recipient: class View: pass class Write: pass @gl.contract.interface class GovernanceAdapter: class View: def get_last_status(self, proposal_id: str) -> dict: ... def get_adapter_kind(self) -> str: ... class Write: pass def _fail(code: str, detail: str) -> None: raise gl.vm.UserError(f"{code}: {detail}") def _now() -> int: fn = getattr(gl, "now", None) if callable(fn): return int(fn()) return int(datetime.now(timezone.utc).timestamp()) def _host_of(url: str) -> str: if not isinstance(url, str) or "://" not in url: _fail("INVALID_URL", "missing scheme") rest = url.split("://", 1)[1] auth = rest.split("/", 1)[0] if "@" in auth: auth = auth.split("@", 1)[1] if auth.startswith("["): end = auth.find("]") if end < 0: _fail("INVALID_URL", "unterminated IPv6 literal") return auth[1:end].lower() return auth.split(":")[0].lower() def _ip_blocked(ip_str: str) -> bool: try: ip = ipaddress.ip_address(ip_str.strip()) except Exception: return True if ip.version == 6 and ip.ipv4_mapped is not None: return _ip_blocked(str(ip.ipv4_mapped)) if ip.version == 6: try: if ip in _NAT64: return _ip_blocked(str(ipaddress.IPv4Address(int(ip) & 0xFFFFFFFF))) except Exception: return True if ip.is_unspecified or ip.is_loopback or ip.is_link_local or ip.is_multicast or ip.is_reserved or ip.is_private: return True if ip.version == 4 and ip in _CGNAT: return True return False def _looks_like_ip(host: str) -> bool: try: ipaddress.ip_address(host) return True except Exception: return False def _name_blocked(host: str) -> bool: h = (host or "").lower().strip(".") if h == "localhost" or h.endswith(".localhost") or h.endswith(".local") or h.endswith(".internal"): return True return h == "metadata.google.internal" def _require_https_public(url: str, label: str) -> None: if not isinstance(url, str) or not url.startswith("https://") or len(url) > 256: _fail("INVALID_URL", f"{label} must be https and <= 256 chars") host = _host_of(url) if not host: _fail("INVALID_URL", f"{label} missing host") if _name_blocked(host) or (_looks_like_ip(host) and _ip_blocked(host)): _fail("SSRF_BLOCKED", f"{label} host is not a public destination") def _body_text(resp) -> str: raw = getattr(resp, "body", None) if isinstance(raw, bytes): return raw.decode("utf-8") if raw is None: return "" return str(raw) def _http_status(resp) -> int: val = getattr(resp, "status", None) if val is None: val = getattr(resp, "status_code", None) try: return int(val) except Exception: return 0 def _doh_lookup(host: str, qtype: str): url = _DOH + "?name=" + host + "&type=" + qtype try: resp = gl.nondet.web.get(url) except Exception as exc: _fail("SSRF_BLOCKED", f"DoH {qtype} {type(exc).__name__}") if _http_status(resp) != 200: _fail("SSRF_BLOCKED", f"DoH {qtype} HTTP {_http_status(resp)}") try: data = json.loads(_body_text(resp)) except Exception: _fail("SSRF_BLOCKED", "DoH response is not JSON") want = 1 if qtype == "A" else 28 out = [] for ans in data.get("Answer") or []: if int(ans.get("type") or 0) != want: continue out.append(str(ans.get("data") or "")) return out def _assert_public_destination(url: str) -> None: if not isinstance(url, str) or not url.startswith("https://"): _fail("SSRF_BLOCKED", "only https destinations are allowed") host = _host_of(url) if _name_blocked(host): _fail("SSRF_BLOCKED", f"blocked name {host}") if _looks_like_ip(host): if _ip_blocked(host): _fail("SSRF_BLOCKED", f"literal IP blocked {host}") return ips = _doh_lookup(host, "A") + _doh_lookup(host, "AAAA") if not ips: _fail("SSRF_BLOCKED", f"no public A/AAAA for {host}") for ip in ips: if _ip_blocked(ip): _fail("SSRF_BLOCKED", f"resolved {host} -> {ip} is not public") def _canonical(obj) -> str: return json.dumps(obj, sort_keys=True, separators=(",", ":"), ensure_ascii=True) def _addr(raw: str, label: str) -> Address: if not isinstance(raw, str) or not _ADDR_RE.match(raw): _fail("INVALID_ADDRESS", f"{label} must be 20-byte 0x-hex") a = Address(raw) if a == _ZERO: _fail("INVALID_ADDRESS", f"{label} is zero") return a def _decimal_to_wad(raw) -> int: if raw is None: return 0 with localcontext() as ctx: ctx.prec = 80 ctx.rounding = ROUND_DOWN d = Decimal(str(raw)) if d < 0: _fail("INVALID_TVL", "negative") return int((d * Decimal(WAD)).to_integral_value(rounding=ROUND_DOWN)) def _ln_wad(x: int) -> int: if int(x) <= 0: _fail("MATH", "ln domain") with localcontext() as ctx: ctx.prec = 80 ctx.rounding = ROUND_DOWN v = (Decimal(int(x)) / Decimal(WAD)).ln() * Decimal(WAD) return int(v.to_integral_value(rounding=ROUND_DOWN)) def _exp_wad(x: int) -> int: with localcontext() as ctx: ctx.prec = 80 ctx.rounding = ROUND_UP v = (Decimal(int(x)) / Decimal(WAD)).exp() * Decimal(WAD) return int(v.to_integral_value(rounding=ROUND_UP)) def _div_wad(a: int, b: int) -> int: if int(b) <= 0: _fail("MATH", "div0") return int(a) * WAD // int(b) def _mul_wad(a: int, b: int) -> int: return int(a) * int(b) // WAD def _lmsr_cost(q_yes: int, q_no: int, b: int) -> int: ey = _exp_wad(_div_wad(q_yes, b)) en = _exp_wad(_div_wad(q_no, b)) s = ey + en c = _mul_wad(b, _ln_wad(s)) m = q_yes if q_yes > q_no else q_no if c < m: return m return c def _lmsr_prices(q_yes: int, q_no: int, b: int): ey = _exp_wad(_div_wad(q_yes, b)) en = _exp_wad(_div_wad(q_no, b)) s = ey + en if s <= 0: return WAD // 2, WAD // 2 return ey * WAD // s, en * WAD // s def _current_tvl_wad(data) -> int: chains = data.get("currentChainTvls") if isinstance(chains, dict) and chains: total = 0 for k, v in chains.items(): lk = str(k).lower() if any(s in lk for s in _DROP): continue total += _decimal_to_wad(v) if total > 0: return total hist = data.get("tvl") if isinstance(hist, list) and hist: last = hist[-1] if isinstance(last, dict): return _decimal_to_wad(last.get("totalLiquidityUSD") or last.get("tvl") or 0) return _decimal_to_wad(last) if "tvl" in data and not isinstance(data.get("tvl"), (list, dict)): return _decimal_to_wad(data.get("tvl")) return 0 def _sampled_tvl_wad(data, sampling_days: int, window_start: int, window_end: int) -> int: points = data.get("tvl") or [] sample_start = window_end - int(sampling_days) * 86400 if sample_start < window_start: sample_start = window_start samples = [] if isinstance(points, list): for p in points: if not isinstance(p, dict): continue d = int(p.get("date") or 0) if sample_start <= d <= window_end: samples.append(_decimal_to_wad(p.get("totalLiquidityUSD") or 0)) if samples: return sum(samples) // len(samples) return _current_tvl_wad(data) class ConditionalTVLMarket(gl.contract.Contract): factory: Address creator: Address governance_adapter: Address fee_sink: Address proposal_id: str methodology_id: str protocol_slug: str llama_api_base: str llama_identity_json: str sources_json: str exclusions_json: str threshold_x: u256 window_days: u256 sampling_window_days: u256 creator_bond: u256 lmsr_b: u256 state: str void_reason: str fraud: bool bond_withdrawn: bool payouts_started: bool execution_timestamp: u256 window_end: u256 created_at: u256 q_yes: u256 q_no: u256 fee_accrued: u256 forfeit_accrued: u256 total_collateral: u256 outstanding_payout: u256 outstanding_refund: u256 creator_credit: u256 appeal_count: u256 first_request_ts: u256 last_resolution_json: str yes_shares: gl.storage.TreeMap[Address, u256] no_shares: gl.storage.TreeMap[Address, u256] collateral_of: gl.storage.TreeMap[Address, u256] def __init__( self, governance_adapter: str, proposal_id: str, methodology_id: str, protocol_slug: str, threshold_x: int, window_days: int, creator_bond: int, fee_sink: str, registry: str, llama_identity_json: str, sources_json: str, exclusions_json: str, sampling_window_days: int, llama_api_base: str, ): if int(gl.message.value) != int(creator_bond): _fail("BOND_MISMATCH", "deploy value must equal creator_bond") if not isinstance(proposal_id, str) or not _PID_RE.match(proposal_id): _fail("INVALID_PROPOSAL_ID", "1..128 chars in [A-Za-z0-9._:-]") if not isinstance(protocol_slug, str) or not _SLUG_RE.match(protocol_slug): _fail("INVALID_SLUG", "protocol_slug must be a lowercase slug") _require_https_public(llama_api_base, "llama_api_base") try: ident = json.loads(llama_identity_json) except Exception: _fail("INVALID_JSON", "llama_identity_json") if not isinstance(ident, dict): _fail("INVALID_JSON", "llama_identity_json must be an object") self.factory = gl.message.sender_address self.creator = gl.message.origin_address self.governance_adapter = _addr(governance_adapter, "governance_adapter") self.fee_sink = _addr(fee_sink, "fee_sink") _addr(registry, "registry") self.proposal_id = proposal_id self.methodology_id = methodology_id self.protocol_slug = protocol_slug self.llama_api_base = llama_api_base.rstrip("/") self.llama_identity_json = _canonical({k: str(ident.get(k) or "") for k in _IDENTITY_KEYS}) self.sources_json = sources_json self.exclusions_json = exclusions_json self.threshold_x = u256(int(threshold_x)) self.window_days = u256(int(window_days)) self.sampling_window_days = u256(int(sampling_window_days)) self.creator_bond = u256(int(creator_bond)) b = int(creator_bond) // 4 if b < WAD: b = WAD self.lmsr_b = u256(b) self.state = "Pending" self.void_reason = "" self.fraud = False self.bond_withdrawn = False self.payouts_started = False self.creator_credit = u256(int(creator_bond)) self.created_at = u256(_now()) def _pay(self, to: Address, amount: int) -> None: amt = int(amount) if amt <= 0: return _Recipient(to).emit_transfer(value=u256(amt)) def _shares_of(self, who: Address, outcome: int) -> int: mp = self.yes_shares if outcome == YES else self.no_shares return int(mp.get(who, u256(0)) or 0) def _set_shares(self, who: Address, outcome: int, value: int) -> None: if outcome == YES: self.yes_shares[who] = u256(value) else: self.no_shares[who] = u256(value) def _add_collateral(self, who: Address, delta: int) -> None: prev = int(self.collateral_of.get(who, u256(0)) or 0) + int(delta) if prev < 0: prev = 0 self.collateral_of[who] = u256(prev) def _void(self, reason: str, fraud: bool) -> None: self.state = "Void" self.void_reason = reason self.fraud = bool(fraud) self.outstanding_payout = u256(0) self.outstanding_refund = u256(int(self.total_collateral)) if fraud: self.forfeit_accrued = u256(int(self.forfeit_accrued) + int(self.creator_bond)) self.creator_credit = u256(0) else: self.creator_credit = u256(int(self.creator_bond)) def _activate(self, execution_timestamp: int) -> None: ts = int(execution_timestamp) now = _now() if ts <= 0: _fail("NOT_EXECUTED", "execution_timestamp required") if ts > now: _fail("INVALID_TIMESTAMP", "execution in the future") self.state = "Active" self.execution_timestamp = u256(ts) self.window_end = u256(ts + int(self.window_days) * 86400) def _apply_governance(self, passed: bool, executed: bool, execution_timestamp: int) -> None: if self.state != "Pending": if self.state == "Active" and passed and executed: return if self.state == "Void" and not passed: return _fail("STATE", f"cannot apply governance from {self.state}") if not passed: self._void("PROPOSAL_REJECTED", False) return if not executed: _fail("NOT_EXECUTED", "passed but not executed; market stays Pending") self._activate(execution_timestamp) @gl.public.view def get_params(self) -> dict: ident = json.loads(self.llama_identity_json) if self.llama_identity_json else {} return { "appeal_count": int(self.appeal_count), "created_at": int(self.created_at), "creator": self.creator.as_hex, "creator_bond": int(self.creator_bond), "execution_timestamp": int(self.execution_timestamp), "factory": self.factory.as_hex, "fee_accrued": int(self.fee_accrued), "fee_sink": self.fee_sink.as_hex, "first_request_ts": int(self.first_request_ts), "fraud": bool(self.fraud), "governance_adapter": self.governance_adapter.as_hex, "last_resolution_json": self.last_resolution_json, "llama_identity": ident, "lmsr_b": int(self.lmsr_b), "methodology_id": self.methodology_id, "proposal_id": self.proposal_id, "protocol_slug": self.protocol_slug, "q_no": int(self.q_no), "q_yes": int(self.q_yes), "sampling_window_days": int(self.sampling_window_days), "state": self.state, "threshold_x": int(self.threshold_x), "void_reason": self.void_reason, "window_days": int(self.window_days), "window_end": int(self.window_end), } @gl.public.view def get_position(self, who: str) -> dict: addr = Address(who) return { "yes": self._shares_of(addr, YES), "no": self._shares_of(addr, NO), "collateral": int(self.collateral_of.get(addr, u256(0)) or 0), } @gl.public.view def quote_buy(self, outcome: int, shares_wad: int) -> dict: return self._quote(int(outcome), int(shares_wad), buy=True) @gl.public.view def quote_sell(self, outcome: int, shares_wad: int) -> dict: return self._quote(int(outcome), int(shares_wad), buy=False) def _quote(self, outcome: int, shares: int, buy: bool) -> dict: if outcome not in (YES, NO): _fail("INVALID_OUTCOME", "outcome must be 0 (yes) or 1 (no)") if shares <= 0: _fail("INVALID_SHARES", "shares must be > 0") b = int(self.lmsr_b) qy, qn = int(self.q_yes), int(self.q_no) if buy: nqy = qy + shares if outcome == YES else qy nqn = qn + shares if outcome == NO else qn else: if outcome == YES: if shares > qy: _fail("INSUFFICIENT_SHARES", "not enough yes liquidity") nqy, nqn = qy - shares, qn else: if shares > qn: _fail("INSUFFICIENT_SHARES", "not enough no liquidity") nqy, nqn = qy, qn - shares before = _lmsr_cost(qy, qn, b) after = _lmsr_cost(nqy, nqn, b) raw = after - before if buy else before - after if raw < 0: raw = 0 fee = raw * FEE_BPS // MAX_BPS py, pn = _lmsr_prices(qy, qn, b) spot = py if outcome == YES else pn avg = raw * WAD // shares if shares else 0 total = raw + fee if buy else (raw - fee if raw > fee else 0) return { "avg_price": avg, "cost": raw if buy else 0, "fee": fee, "proceeds": raw if not buy else 0, "spot_price": spot, "total": total, } @gl.public.write def on_proposal_finalized(self, passed: bool, execution_timestamp: int) -> None: if gl.message.sender_address != self.governance_adapter: _fail("UNAUTHORIZED", "on_proposal_finalized is adapter-only") self._apply_governance(bool(passed), bool(passed) and int(execution_timestamp) > 0, int(execution_timestamp)) @gl.public.write def advance_from_governance(self) -> None: adapter = GovernanceAdapter(self.governance_adapter) status = adapter.view().get_last_status(self.proposal_id) if not isinstance(status, dict) or "passed" not in status: _fail("STATUS_NOT_CHECKED", self.proposal_id) self._apply_governance(bool(status.get("passed")), bool(status.get("executed")), int(status.get("execution_timestamp") or 0)) @gl.public.write def resolve_market(self, consensus_payload: str) -> None: _fail("CONSENSUS_ONLY", "resolve_market is not callable; resolution is applied inside request_resolution") @gl.public.write.payable def buy_shares(self, outcome: int, shares_wad: int, max_slippage_bps: int) -> None: if self.state != "Active": _fail("STATE", "buy is Active-only") try: bps = int(max_slippage_bps) except Exception: _fail("INVALID_SLIPPAGE", "max_slippage_bps") if bps < 0 or bps > MAX_BPS: _fail("INVALID_SLIPPAGE", "max_slippage_bps 0..10000") q = self._quote(int(outcome), int(shares_wad), buy=True) limit = int(q["spot_price"]) * (MAX_BPS + bps) // MAX_BPS if int(q["avg_price"]) > limit: _fail("SLIPPAGE", "execution price exceeds max_slippage_bps") paid = int(gl.message.value) need = int(q["total"]) if paid < need: _fail("INSUFFICIENT_VALUE", f"need {need}") sender = gl.message.sender_address shares = int(shares_wad) if int(outcome) == YES: self.q_yes = u256(int(self.q_yes) + shares) else: self.q_no = u256(int(self.q_no) + shares) self._set_shares(sender, int(outcome), self._shares_of(sender, int(outcome)) + shares) cost = int(q["cost"]) self._add_collateral(sender, cost) self.total_collateral = u256(int(self.total_collateral) + cost) self.fee_accrued = u256(int(self.fee_accrued) + int(q["fee"])) if paid > need: self._pay(sender, paid - need) @gl.public.write def sell_shares(self, outcome: int, shares_wad: int, min_slippage_bps: int) -> None: if self.state != "Active": _fail("STATE", "sell is Active-only") try: bps = int(min_slippage_bps) except Exception: _fail("INVALID_SLIPPAGE", "min_slippage_bps") if bps < 0 or bps > MAX_BPS: _fail("INVALID_SLIPPAGE", "min_slippage_bps 0..10000") sender = gl.message.sender_address shares = int(shares_wad) owned = self._shares_of(sender, int(outcome)) if shares > owned: _fail("INSUFFICIENT_SHARES", "not enough shares") q = self._quote(int(outcome), shares, buy=False) limit = int(q["spot_price"]) * (MAX_BPS - bps) // MAX_BPS if int(q["avg_price"]) < limit: _fail("SLIPPAGE", "execution price below min_slippage_bps") if int(outcome) == YES: self.q_yes = u256(int(self.q_yes) - shares) else: self.q_no = u256(int(self.q_no) - shares) self._set_shares(sender, int(outcome), owned - shares) proceeds = int(q["proceeds"]) fee = int(q["fee"]) self._add_collateral(sender, -proceeds) tc = int(self.total_collateral) - proceeds self.total_collateral = u256(tc if tc > 0 else 0) self.fee_accrued = u256(int(self.fee_accrued) + fee) self._pay(sender, int(q["total"])) @gl.public.write def request_resolution(self) -> None: now = _now() if self.state == "Active": if now < int(self.window_end): _fail("TOO_EARLY", "window has not ended") self.state = "ResolutionRequested" if int(self.first_request_ts) == 0: self.first_request_ts = u256(now) elif self.state != "ResolutionRequested": _fail("STATE", f"cannot request resolution from {self.state}") url = self.llama_api_base.rstrip("/") + "/protocol/" + self.protocol_slug frozen_ident = self.llama_identity_json slug = self.protocol_slug threshold = int(self.threshold_x) sampling = int(self.sampling_window_days) window_start = int(self.execution_timestamp) window_end = int(self.window_end) def fetch_decision() -> str: _assert_public_destination(url) resp = gl.nondet.web.get(url) if _http_status(resp) != 200: return _canonical({"reason": f"HTTP {_http_status(resp)}", "status": "unavailable"}) try: data = json.loads(_body_text(resp)) except Exception: return _canonical({"reason": "json", "status": "unavailable"}) if not isinstance(data, dict): return _canonical({"reason": "not-object", "status": "unavailable"}) frozen = json.loads(frozen_ident) live = {k: str(data.get(k) or "") for k in _IDENTITY_KEYS} for k in _IDENTITY_KEYS: if str(frozen.get(k) or "") != live[k]: return _canonical( { "expected": frozen, "observed": live, "slug": slug, "status": "fraud", } ) tvl = _sampled_tvl_wad(data, sampling, window_start, window_end) yes = tvl >= threshold return _canonical( { "exclusions_applied": ["protocol_owned_liquidity", "treasury", "wrapped_duplicate"], "exclusions_pending": ["dao_voter"], "status": "yes" if yes else "no", "threshold_wad": threshold, "tvl_wad": tvl, } ) raw = gl.eq_principle.strict_eq(fetch_decision) self.last_resolution_json = raw payload = json.loads(raw) status = payload.get("status") if status == "unavailable": return if status == "fraud": self._void("PROTOCOL_SLUG_FRAUD", True) return if status in ("yes", "no"): win_yes = status == "yes" self.state = "ResolvedYes" if win_yes else "ResolvedNo" win_q = int(self.q_yes) if win_yes else int(self.q_no) self.outstanding_payout = u256(win_q) self.outstanding_refund = u256(0) credit = int(self.creator_bond) + int(self.total_collateral) - win_q self.creator_credit = u256(credit if credit > 0 else 0) return _fail("INVALID_RESOLUTION", str(status)) @gl.public.write.payable def escalate_resolution(self) -> None: if self.payouts_started: _fail("APPEAL_TOO_LATE", "claims already started") if int(self.appeal_count) >= MAX_APPEALS: _fail("MAX_APPEALS", "max 2 appeals") if self.state not in ("ResolvedYes", "ResolvedNo", "ResolutionFailed", "ResolutionRequested"): _fail("STATE", f"cannot appeal from {self.state}") need = MIN_APPEAL_BOND * (2 ** int(self.appeal_count)) paid = int(gl.message.value) if paid < need: _fail("APPEAL_BOND", f"need {need}") self.fee_accrued = u256(int(self.fee_accrued) + paid) self.appeal_count = u256(int(self.appeal_count) + 1) self.outstanding_payout = u256(0) self.state = "ResolutionRequested" if paid > need: self._pay(gl.message.sender_address, paid - need) @gl.public.write def finalize_after_failed_consensus(self) -> None: if self.state != "ResolutionRequested": _fail("STATE", "finalize only from ResolutionRequested") last = {} if self.last_resolution_json: try: last = json.loads(self.last_resolution_json) except Exception: last = {} unavailable = last.get("status") == "unavailable" or last.get("status") is None if not unavailable: _fail("STATE", "last payload is a decision, not a failure") now = _now() retry_elapsed = int(self.window_end) > 0 and now >= int(self.window_end) + RETRY_SECONDS if int(self.appeal_count) >= MAX_APPEALS or retry_elapsed: self.state = "ResolutionFailed" self._void("RESOLUTION_FAILED", False) return _fail("TOO_EARLY", "retry window still open and appeals remain") @gl.public.write def cancel_unstarted(self) -> None: sender = gl.message.sender_address if sender != self.creator and sender != self.factory: _fail("UNAUTHORIZED", "only creator or factory may cancel") if self.state != "Pending": _fail("STATE", "cancel only while Pending") if int(self.q_yes) or int(self.q_no): _fail("SHARES_EXIST", "shares already purchased") self.state = "Void" self.void_reason = "CANCELLED" self.bond_withdrawn = True self.creator_credit = u256(0) self._pay(self.creator, int(self.creator_bond)) @gl.public.write def claim_payout(self) -> None: if self.state not in ("ResolvedYes", "ResolvedNo"): _fail("STATE", "payout only after ResolvedYes/ResolvedNo") self.payouts_started = True sender = gl.message.sender_address won = self._shares_of(sender, YES if self.state == "ResolvedYes" else NO) if won <= 0: _fail("NO_PAYOUT", "no winning shares") self._set_shares(sender, YES, 0) self._set_shares(sender, NO, 0) self.collateral_of[sender] = u256(0) op = int(self.outstanding_payout) - won self.outstanding_payout = u256(op if op > 0 else 0) self._pay(sender, won) @gl.public.write def claim_refund(self) -> None: if self.state != "Void": _fail("STATE", "refund only in Void") self.payouts_started = True sender = gl.message.sender_address amt = int(self.collateral_of.get(sender, u256(0)) or 0) if amt <= 0: _fail("NO_REFUND", "no collateral") self.collateral_of[sender] = u256(0) self._set_shares(sender, YES, 0) self._set_shares(sender, NO, 0) rf = int(self.outstanding_refund) - amt self.outstanding_refund = u256(rf if rf > 0 else 0) tc = int(self.total_collateral) - amt self.total_collateral = u256(tc if tc > 0 else 0) self._pay(sender, amt) @gl.public.write def withdraw_creator_bond(self) -> None: if gl.message.sender_address != self.creator: _fail("UNAUTHORIZED", "only creator") if self.fraud: _fail("FRAUD_FORFEIT", "creator bond forfeited on protocolSlug fraud") if self.state not in _TERMINAL: _fail("STATE", "bond only after Void or resolution") if self.bond_withdrawn: _fail("ALREADY", "bond already withdrawn") amt = int(self.creator_credit) self.bond_withdrawn = True self.creator_credit = u256(0) self.payouts_started = True self._pay(self.creator, amt) @gl.public.write def withdraw_fees(self) -> None: fee = int(self.fee_accrued) + int(self.forfeit_accrued) if fee <= 0: _fail("NO_FEES", "nothing to withdraw") self.fee_accrued = u256(0) self.forfeit_accrued = u256(0) self._pay(self.fee_sink, fee)