Chore: update twap price

Author: devWorld335

src/client/chainlink_client/chainlink_client.py

@@ -149,10 +149,9 @@ def last_update_time(self) -> Optional[int]:
 
     def get_price_at_timestamp(self, timestamp: int | float | str) -> float:
         """
-        Get the Chainlink Data Streams benchmark price for this feed at a specific Unix timestamp (seconds).
+        Get the Chainlink Data Streams price for this feed at a Unix timestamp (seconds).
 
-        Uses the authenticated Data Streams API to fetch the report at the given time
-        and returns the decoded benchmark price.
+        For 5m markets use the TWAP-30 feed (``CHAINLINK_TWAP_30S_FEED_ID``).
         """
         if not self.feed_id:
             raise ValueError("feed_id is not set; cannot get report")

src/client/coinbase_client/coinbase_client.py

@@ -339,6 +339,7 @@ def _dispatch_loop(self) -> None:
                 if not isinstance(price, (int, float)):
                     continue
                 price_f = float(price)
+                print(f"Coinbase price: {price_f}")
                 side = msg.get("side")
                 # Order matters: write the timestamp last so a reader
                 # that observes a fresh COIN_BASE_LAST_UPDATE_MS is

src/client/polymarket_twap_client/polymarket_twap_client.py

@@ -1,9 +1,10 @@
 """
-Polymarket Chainlink price streams via Polymarket RTDS (no Chainlink API keys).
+Polymarket Chainlink TWAP-30 stream via Polymarket RTDS (no Chainlink API keys).
 
-Subscribes to:
-- ``prices.crypto.chainlink`` → benchmark → ``config.CURRENT_PRICE``
-- ``prices.crypto.chainlink.twap`` (30s) → ``config.CURRENT_TWAP_PRICE`` (settlement only)
+For 5-minute BTC UP/DOWN markets, Polymarket resolves using Chainlink TWAP-30
+(beat at open, settlement at end). This client subscribes to
+``prices.crypto.chainlink.twap`` (30s) and mirrors values into
+``config.CURRENT_TWAP_PRICE`` and ``config.CURRENT_PRICE`` (legacy alias).
 """
 from __future__ import annotations
 
@@ -26,13 +27,12 @@
 
 try:
     from polymarket import AsyncPublicClient
-    from polymarket.streams import CryptoPricesChainlinkTwapSpec, CryptoPricesSpec
+    from polymarket.streams import CryptoPricesChainlinkTwapSpec
 
     POLYMARKET_CHAINLINK_AVAILABLE = True
 except ImportError:
     AsyncPublicClient = None  # type: ignore[assignment,misc]
     CryptoPricesChainlinkTwapSpec = None  # type: ignore[assignment,misc]
-    CryptoPricesSpec = None  # type: ignore[assignment,misc]
     POLYMARKET_CHAINLINK_AVAILABLE = False
 
 # Back-compat alias used elsewhere in the repo.
@@ -45,7 +45,7 @@ def _asset_to_symbol(asset: str) -> str:
 
 
 class PolymarketTwapClient:
-    """Polymarket RTDS: Chainlink benchmark + TWAP-30 background streams."""
+    """Polymarket RTDS: Chainlink TWAP-30 background stream."""
 
     def __init__(
         self,
@@ -61,14 +61,12 @@ def __init__(
         self._stop = threading.Event()
         self._running = False
 
-        self._last_benchmark: Optional[float] = None
         self._last_twap: Optional[float] = None
-        self._last_benchmark_ts_ms: Optional[int] = None
         self._last_twap_ts_ms: Optional[int] = None
 
     @property
     def last_price(self) -> Optional[float]:
-        """Last TWAP price (legacy alias)."""
+        """Last TWAP-30 price."""
         return self._last_twap
 
     @property
@@ -80,15 +78,15 @@ def start(self) -> None:
             return
         if not POLYMARKET_CHAINLINK_AVAILABLE:
             logger.warning(
-                "polymarket-client not installed; Chainlink streams disabled. "
+                "polymarket-client not installed; Chainlink TWAP stream disabled. "
                 "pip install polymarket-client"
             )
             return
         self._running = True
         self._stop.clear()
         self._thread = threading.Thread(
             target=self._run_thread,
-            name="polymarket-chainlink",
+            name="polymarket-chainlink-twap",
             daemon=True,
         )
         self._thread.start()
@@ -103,18 +101,8 @@ def stop(self) -> None:
                 pass
             self._thread = None
 
-    def wait_for_benchmark(self, timeout_sec: float = 15.0) -> Optional[float]:
-        """Block until a positive Chainlink benchmark price arrives."""
-        deadline = time.time() + timeout_sec
-        while time.time() < deadline:
-            px = config.CURRENT_PRICE
-            if px and px > 0:
-                return float(px)
-            time.sleep(0.2)
-        return None
-
     def wait_for_twap(self, timeout_sec: float = 15.0) -> Optional[float]:
-        """Block until a positive TWAP price arrives (use after market end)."""
+        """Block until a positive Chainlink TWAP-30 price arrives."""
         deadline = time.time() + timeout_sec
         while time.time() < deadline:
             px = config.CURRENT_TWAP_PRICE
@@ -123,28 +111,40 @@ def wait_for_twap(self, timeout_sec: float = 15.0) -> Optional[float]:
             time.sleep(0.2)
         return None
 
+    def wait_for_benchmark(self, timeout_sec: float = 15.0) -> Optional[float]:
+        """Legacy alias → ``wait_for_twap`` (beat/settlement use TWAP-30)."""
+        return self.wait_for_twap(timeout_sec)
+
     def wait_for_price(self, timeout_sec: float = 15.0) -> Optional[float]:
         """Legacy alias → ``wait_for_twap``."""
         return self.wait_for_twap(timeout_sec)
 
+    def _set_twap(self, price: float, obs_ms: object) -> None:
+        config.CURRENT_TWAP_PRICE = price
+        config.CURRENT_PRICE = price  # legacy alias
+        self._last_twap = price
+        if obs_ms is not None:
+            ts = float(obs_ms)
+            config.CURRENT_TWAP_TS_MS = ts
+            config.CURRENT_PRICE_TS_MS = ts  # legacy alias
+            self._last_twap_ts_ms = int(obs_ms)
+
     def _run_thread(self) -> None:
         while self._running and not self._stop.is_set():
             try:
                 asyncio.run(self._stream_loop())
             except Exception:
-                logger.exception("Polymarket Chainlink stream error")
+                logger.exception("Polymarket Chainlink TWAP stream error")
             if self._stop.is_set() or not self._running:
                 break
-            logger.warning("Polymarket Chainlink stream ended; reconnecting in 5s")
+            logger.warning("Polymarket Chainlink TWAP stream ended; reconnecting in 5s")
             time.sleep(5.0)
 
     async def _stream_loop(self) -> None:
         assert AsyncPublicClient is not None
-        assert CryptoPricesSpec is not None
         assert CryptoPricesChainlinkTwapSpec is not None
 
         specs = [
-            CryptoPricesSpec(topic="prices.crypto.chainlink", symbols=[self.symbol]),
             CryptoPricesChainlinkTwapSpec(
                 window_seconds=self.window_seconds,
                 symbols=[self.symbol],
@@ -154,31 +154,17 @@ async def _stream_loop(self) -> None:
             async with await client.subscribe(specs) as stream:
                 if self._debug:
                     print(
-                        f"✅ Polymarket Chainlink streams connected "
-                        f"({self.symbol}, benchmark + TWAP {self.window_seconds}s)"
+                        f"✅ Polymarket Chainlink TWAP stream connected "
+                        f"({self.symbol}, {self.window_seconds}s)"
                     )
                 async for event in stream:
                     if self._stop.is_set():
                         break
-                    topic = getattr(event, "topic", "")
                     payload = event.payload
                     try:
                         price = float(payload.value)
                     except (TypeError, ValueError):
                         continue
                     if price <= 0:
                         continue
-                    obs_ms = getattr(payload, "timestamp", None)
-
-                    if topic == "prices.crypto.chainlink":
-                        config.CURRENT_PRICE = price
-                        self._last_benchmark = price
-                        if obs_ms is not None:
-                            config.CURRENT_PRICE_TS_MS = float(obs_ms)
-                            self._last_benchmark_ts_ms = int(obs_ms)
-                    elif topic == "prices.crypto.chainlink.twap":
-                        config.CURRENT_TWAP_PRICE = price
-                        self._last_twap = price
-                        if obs_ms is not None:
-                            config.CURRENT_TWAP_TS_MS = float(obs_ms)
-                            self._last_twap_ts_ms = int(obs_ms)
+                    self._set_twap(price, getattr(payload, "timestamp", None))

src/config/config.py

@@ -93,12 +93,11 @@ def round_usdc(value: float) -> float:
 DIFF: float = 0.0
 PREV_MOMENTUM_PRICE: float = 0.0
 
-CURRENT_PRICE: float = 0.0
-# Chainlink benchmark observation time (ms) from Polymarket RTDS.
-CURRENT_PRICE_TS_MS: float = 0.0
+# Chainlink TWAP-30 (5m market beat/settlement). CURRENT_* are legacy aliases.
 CURRENT_TWAP_PRICE: float = 0.0
-# Chainlink observation time (ms) from the latest Polymarket TWAP event payload.
 CURRENT_TWAP_TS_MS: float = 0.0
+CURRENT_PRICE: float = 0.0
+CURRENT_PRICE_TS_MS: float = 0.0
 # Settlement TWAP captured closest to market end (set by arb bots).
 END_TWAP_PRICE: float = 0.0
 

src/script/arb_bot_paper.py

@@ -55,7 +55,7 @@ def _sanitize_slug(slug: str) -> str:
 
 
 def _save_chainlink_market_log(slug: str | None, record: dict) -> str | None:
-    """Write beat + final-30s benchmark samples + end TWAP to logs/chainlink/."""
+    """Write beat + final-30s TWAP samples + end TWAP to logs/chainlink/."""
     safe_slug = _sanitize_slug(slug or record.get("slug") or "unknown-market")
     record = {**record, "slug": safe_slug}
     path = os.path.join(CHAINLINK_LOG_DIR, f"{safe_slug}.json")
@@ -76,23 +76,23 @@ def _save_chainlink_market_log(slug: str | None, record: dict) -> str | None:
     return path
 
 
-# The end TWAP is the arithmetic mean of the per-second benchmark prices over
-# the final TWAP_WINDOW_SECONDS. Once N samples are known, N/30 of the result is
-# already fixed; the rest is estimated by holding the current benchmark flat.
+# End settlement TWAP ≈ mean of per-second TWAP-30 samples over the final window.
+# Once N samples are known, N/30 of the result is fixed; the rest is estimated
+# by holding the current TWAP flat.
 TWAP_WINDOW_SECONDS = 30
 PREDICT_AT_SECONDS_LEFT = 5
 # Calls closer than this to the beat price sit inside the estimator's noise band.
 MIN_PREDICT_MARGIN = 1.0
-# A benchmark this old means the Chainlink stream stalled; the estimate is unusable.
-MAX_BENCHMARK_AGE_MS = 3000.0
+# A TWAP update this old means the Chainlink stream stalled; estimate is unusable.
+MAX_TWAP_AGE_MS = 3000.0
 
 _pred_total = 0
 _pred_correct = 0
 _pred_abs_err_sum = 0.0
 
 
 def _predict_end_twap(prices: list[float], current: float) -> float | None:
-    """Estimate the final TWAP from the benchmark samples seen so far.
+    """Estimate the final TWAP from TWAP-30 samples seen so far.
 
     Unknown seconds are filled with ``current`` (flat-hold assumption).
     """
@@ -638,14 +638,14 @@ def _main_impl():
         end_ts = bot.current_market_end_timestamp
         config.END_TWAP_PRICE = 0.0
 
-        # Beat = Chainlink benchmark at market open.
-        beat = bot.polymarket_twap_client.wait_for_benchmark(timeout_sec=10.0)
+        # Beat = Chainlink TWAP-30 at market open.
+        beat = bot.polymarket_twap_client.wait_for_twap(timeout_sec=10.0)
         if beat is not None and beat > 0:
             config.PRICE_TO_BEAT = float(beat)
             config.PRICE_TO_BEAT_COINBASE = float(beat)
-            print(f"PRICE TO BEAT (benchmark): {config.PRICE_TO_BEAT:.2f}")
+            print(f"PRICE TO BEAT (TWAP-30): {config.PRICE_TO_BEAT:.2f}")
         else:
-            print("⚠️ Could not get opening benchmark from Polymarket stream")
+            print("⚠️ Could not get opening TWAP-30 from Polymarket stream")
 
         # Wait until the final 30 seconds of this market.
         if end_ts:
@@ -654,39 +654,39 @@ def _main_impl():
                 time.sleep(0.5)
 
         beat = config.PRICE_TO_BEAT
-        benchmark_final_30s: list[dict] = []
+        twap_final_30s: list[dict] = []
         prediction: dict | None = None
 
-        # Final 30s: Chainlink benchmark prices (T-30 → T-0), one sample per second.
+        # Final 30s: Chainlink TWAP-30 (T-30 → T-0), one sample per second.
         while end_ts and time.time() < end_ts + 1:
             _ensure_websocket_and_subscribe(bot, ws_url, prev_token_ids)
 
             now = time.time()
             seconds_left = end_ts - now
-            benchmark = config.CURRENT_PRICE
-            if benchmark > 0 and end_ts - 30 <= now <= end_ts:
-                side = "UP" if beat > 0 and benchmark > beat else ("DOWN" if beat > 0 else "?")
+            twap = config.CURRENT_TWAP_PRICE
+            if twap > 0 and end_ts - 30 <= now <= end_ts:
+                side = "UP" if beat > 0 and twap > beat else ("DOWN" if beat > 0 else "?")
                 dt = datetime.fromtimestamp(now, timezone.utc)
-                benchmark_final_30s.append({
+                twap_final_30s.append({
                     "ts": round(now, 3),
                     "iso": dt.isoformat(),
                     "seconds_left": round(seconds_left, 1),
-                    "benchmark_price": round(benchmark, 2),
+                    "twap_price": round(twap, 2),
                     "vs_beat": side,
                 })
                 print(
                     f"{dt.strftime('%d/%m/%Y, %-H:%M:%S %Z')} | "
-                    f"T-{seconds_left:.0f}s | benchmark={benchmark:.2f} | beat={beat:.2f} | {side}"
+                    f"T-{seconds_left:.0f}s | twap={twap:.2f} | beat={beat:.2f} | {side}"
                 )
 
                 if prediction is None and seconds_left <= PREDICT_AT_SECONDS_LEFT:
-                    prices = [s["benchmark_price"] for s in benchmark_final_30s]
-                    est = _predict_end_twap(prices, benchmark)
+                    prices = [s["twap_price"] for s in twap_final_30s]
+                    est = _predict_end_twap(prices, twap)
                     if est is not None:
-                        age_ms = (now * 1000.0) - config.CURRENT_PRICE_TS_MS
+                        age_ms = (now * 1000.0) - config.CURRENT_TWAP_TS_MS
                         stale = (
-                            config.CURRENT_PRICE_TS_MS <= 0
-                            or age_ms > MAX_BENCHMARK_AGE_MS
+                            config.CURRENT_TWAP_TS_MS <= 0
+                            or age_ms > MAX_TWAP_AGE_MS
                             or len(set(prices)) < 2
                         )
                         margin = est - beat if beat > 0 else 0.0
@@ -698,11 +698,11 @@ def _main_impl():
                             "seconds_left": round(seconds_left, 1),
                             "samples_known": len(prices),
                             "locked_fraction": round(len(prices) / TWAP_WINDOW_SECONDS, 3),
-                            "current_benchmark": round(benchmark, 2),
+                            "current_twap": round(twap, 2),
                             "predicted_twap": round(est, 2),
                             "margin_vs_beat": round(margin, 2),
                             "predicted_side": pred_side,
-                            "benchmark_age_ms": round(max(age_ms, 0.0), 1),
+                            "twap_age_ms": round(max(age_ms, 0.0), 1),
                             "stale_feed": stale,
                         }
                         print(
@@ -721,7 +721,7 @@ def _main_impl():
 
         result = None
         print(f"END TWAP: {end_twap}")
-        print(f"PRICE TO BEAT (benchmark): {config.PRICE_TO_BEAT}")
+        print(f"PRICE TO BEAT (TWAP-30): {config.PRICE_TO_BEAT}")
 
         if end_twap is not None and config.PRICE_TO_BEAT > 0:
             if end_twap > config.PRICE_TO_BEAT:
@@ -734,7 +734,7 @@ def _main_impl():
             print("⚠️ Settlement skipped — missing end TWAP or beat price")
 
         if prediction is None:
-            print("🔮 PREDICTION: none made this market (no benchmark samples in final 5s)")
+            print("🔮 PREDICTION: none made this market (no TWAP samples in final 5s)")
         elif end_twap is None:
             print("🔮 PREDICTION: cannot verify — no end TWAP")
         else:
@@ -773,7 +773,7 @@ def _main_impl():
             "market_start_ts": int(start_ts) if start_ts else None,
             "market_end_ts": int(end_ts) if end_ts else None,
             "beat_price": round(config.PRICE_TO_BEAT, 2) if config.PRICE_TO_BEAT else None,
-            "benchmark_prices_final_30s": benchmark_final_30s,
+            "twap_prices_final_30s": twap_final_30s,
             "end_twap_price": round(end_twap, 2) if end_twap is not None else None,
             "result": result,
             "prediction": prediction,