# { "Depends": "py-genlayer:5jycge4q8k23462jtb0b9fyey1s9qz928sz2nbrd9mg4sxqg2qng" } import json import genlayer as gl from genlayer import u256 OUTCOME_COUNT = 3 PRICE_SCALE = 1_000_000_000_000_000_000 RETURN_SCALE = 1_000_000 MAX_RESPONSE_BYTES = 65_536 MAX_SOURCE_ATTEMPTS = 4 U256_MAX = 2**256 - 1 SOURCE_BINANCE = "BINANCE" SOURCE_GATE = "GATE" SOURCE_BITGET = "BITGET" def _is_u256(value) -> bool: return isinstance(value, int) and not isinstance(value, bool) and 0 <= value <= U256_MAX def _category_id(category) -> u256: if category == "US_INDICES": return 0 if category == "ASIA_INDICES": return 1 if category == "SECTOR_INDICES": return 2 raise gl.vm.UserError("invalid category") def _category_name(category: u256) -> str: if category == 0: return "US_INDICES" if category == 1: return "ASIA_INDICES" if category == 2: return "SECTOR_INDICES" raise gl.vm.UserError("invalid category") def _asset_names(category: u256) -> list[str]: if category == 0: return ["SPY", "QQQ", "IWM"] if category == 1: return ["EWJ", "EWY", "EWT"] if category == 2: return ["SMH", "XBI", "XLE"] raise gl.vm.UserError("invalid category") def _symbol(source: str, category: u256, asset: u256) -> str: name = _asset_names(category)[asset] return name + ("_USDT" if source == SOURCE_GATE else "USDT") def _parse_integer(value) -> int | None: 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 value: return None for char in value: if char < "0" or char > "9": return None number = int(value) return number if number <= 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 text.startswith("-"): return None pieces = text.split(".") if len(pieces) > 2 or not pieces[0] or len(pieces[0]) > 38: return None for char in pieces[0]: if char < "0" or char > "9": return None fraction = pieces[1] if len(pieces) == 2 else "" if fraction and (len(fraction) > 18 or not all("0" <= char <= "9" for char in fraction)): return None scaled = int(pieces[0]) * PRICE_SCALE + int((fraction + "0" * 18)[:18]) if scaled <= 0 or scaled > U256_MAX: return None canonical_fraction = fraction.rstrip("0") canonical = str(int(pieces[0])) if canonical_fraction: canonical += "." + canonical_fraction return scaled, canonical def _return_units(open_scaled: int, close_scaled: int) -> int: numerator = (close_scaled - open_scaled) * 100 * RETURN_SCALE if numerator >= 0: return (numerator + open_scaled // 2) // open_scaled return -((-numerator + open_scaled // 2) // open_scaled) def _compare_return(left_open: int, left_close: int, right_open: int, right_close: int) -> int: left_delta = left_close - left_open right_delta = right_close - right_open left_cross = left_delta * right_open right_cross = right_delta * left_open if left_cross > right_cross: return 1 if left_cross < right_cross: return -1 return 0 def _request_json(url: str): try: response = gl.nondet.web.get(url, headers={"Accept": "application/json"}) if response.status != 200 or response.body is None or len(response.body) > MAX_RESPONSE_BYTES: return None return json.loads(response.body.decode("utf-8")) except (gl.nondet.NondetException, gl.vm.UserError, ValueError, TypeError, UnicodeError, AttributeError): return None def _array_candle(payload, timestamp: int, source: str): if not isinstance(payload, list) or len(payload) != 1 or not isinstance(payload[0], list): return None row = payload[0] expected_length = 12 if source == SOURCE_BINANCE else 7 if len(row) != expected_length or _parse_integer(row[0]) != timestamp: return None if source == SOURCE_BINANCE and _parse_integer(row[6]) != timestamp + 3_599_999: return None opening = _parse_price(row[1]) high = _parse_price(row[2]) low = _parse_price(row[3]) closing = _parse_price(row[4]) if opening is None or high is None or low is None or closing is None: return None return timestamp, opening, closing def _gate_candle(payload, timestamp: int, symbol: str): if not isinstance(payload, list) or len(payload) != 1: return None row = payload[0] if not isinstance(row, list) or len(row) != 7 or _parse_integer(row[0]) != timestamp: return None opening = _parse_price(row[5]) high = _parse_price(row[3]) low = _parse_price(row[4]) closing = _parse_price(row[2]) if opening is None or high is None or low is None or closing is None: return None return timestamp, opening, closing def _fetch_candle(source: str, category: u256, asset: u256, start_seconds: u256, end_seconds: u256): symbol = _symbol(source, category, asset) start_ms = start_seconds * 1000 end_ms = end_seconds * 1000 if source == SOURCE_BINANCE: url = "https://fapi.binance.com/fapi/v1/klines?symbol=" + symbol + "&interval=1h&startTime=" + str(start_ms) + "&endTime=" + str(end_ms) + "&limit=1" return _array_candle(_request_json(url), start_ms, SOURCE_BINANCE) if source == SOURCE_GATE: url = "https://api.gateio.ws/api/v4/futures/usdt/candlesticks?contract=" + symbol + "&interval=1h&from=" + str(start_seconds) + "&to=" + str(end_seconds - 1) return _gate_candle(_request_json(url), start_seconds, symbol) url = "https://api.bitget.com/api/v3/market/candles?category=USDT-FUTURES&symbol=" + symbol + "&interval=1H&type=market&startTime=" + str(start_ms) + "&endTime=" + str(end_ms - 1) + "&limit=1" payload = _request_json(url) if not isinstance(payload, dict) or payload.get("code") != "00000" or "data" not in payload: return None return _array_candle(payload["data"], start_ms, SOURCE_BITGET) def _source_result(source: str, category: u256, start: u256, end: u256) -> dict: rows = [] names = _asset_names(category) for asset in range(OUTCOME_COUNT): candle = _fetch_candle(source, category, asset, start, end) if candle is None: return {"source": source, "status": "UNAVAILABLE", "winner": "", "assets": []} timestamp, opening, closing = candle rows.append({ "asset": names[asset], "symbol": _symbol(source, category, asset), "timestamp": timestamp, "timestamp_unit": "s" if source == SOURCE_GATE else "ms", "open": opening[1], "close": closing[1], "return_units": _return_units(opening[0], closing[0]), "_open_scaled": opening[0], "_close_scaled": closing[0], }) winner = 0 tied = False for asset in range(1, OUTCOME_COUNT): comparison = _compare_return(rows[asset]["_open_scaled"], rows[asset]["_close_scaled"], rows[winner]["_open_scaled"], rows[winner]["_close_scaled"]) if comparison > 0: winner = asset tied = False elif comparison == 0: tied = True for row in rows: del row["_open_scaled"] del row["_close_scaled"] return {"source": source, "status": "TIE" if tied else "VALID", "winner": "" if tied else names[winner], "assets": rows} def _source_with_retries(source: str, category: u256, start: u256, end: u256) -> dict: result = {"source": source, "status": "UNAVAILABLE", "winner": "", "assets": []} for _ in range(MAX_SOURCE_ATTEMPTS): result = _source_result(source, category, start, end) if result["status"] != "UNAVAILABLE": return result return result def _consensus_winner(results: list[dict]) -> str: votes = [result["winner"] if result["status"] == "VALID" else "" for result in results] if votes[0] and votes[0] == votes[1]: return votes[0] if votes[0] and votes[0] == votes[2]: return votes[0] if votes[1] and votes[1] == votes[2]: return votes[1] return "" def _probe(category: str, start: u256, end: u256) -> str: category_id = _category_id(category) results = [_source_with_retries(source, category_id, start, end) for source in (SOURCE_BINANCE, SOURCE_GATE, SOURCE_BITGET)] return json.dumps({ "category": _category_name(category_id), "market_start": start, "market_end": end, "interval": "1h", "results": results, "consensus_winner": _consensus_winner(results), }, separators=(",", ":"), sort_keys=True) class OutrunSourceProbe(gl.contract.Contract): @gl.public.write def probe_category(self, category: str, market_start: u256, market_end: u256) -> str: if not isinstance(category, str) or not _is_u256(market_start) or not _is_u256(market_end): raise gl.vm.UserError("invalid probe input") if market_end != market_start + 3600: raise gl.vm.UserError("probe window must be one hour") def leader_fn(): return _probe(category, market_start, market_end) def validator_fn(leaders_result) -> bool: if not isinstance(leaders_result, gl.vm.Return): return False try: return leaders_result.calldata == _probe(category, market_start, market_end) except Exception: return False return gl.vm.run_nondet(leader_fn, validator_fn)