import sys
import json
import datetime
from pathlib import Path

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

sys.path.insert(0, str(Path.cwd().parent / "src"))
import kalshi_client
import polymarket_client
import market_matching
import fees
import events_config

sns.set_theme(style="whitegrid")
pd.set_option("display.width", 140)

DATA_RAW = Path.cwd().parent / "data" / "raw"
DATA_PROCESSED = Path.cwd().parent / "data" / "processed"
DATA_RAW.mkdir(parents=True, exist_ok=True)
DATA_PROCESSED.mkdir(parents=True, exist_ok=True)

kalshi_full_event_markets = kalshi_client.get_historical_markets("KXFEDDECISION-26JAN")

kalshi_full_event_data = {}
for m in kalshi_full_event_markets:
    ticker = m["ticker"]
    market_open = pd.to_datetime(m["open_time"], utc=True)
    market_close = pd.to_datetime(m["close_time"], utc=True)
    kalshi_full_event_data[ticker] = kalshi_client.get_candlesticks(
        ticker, market_open, market_close, period_interval=1
    )

from IPython.display import Markdown, display

KALSHI_TICKER = "KXFEDDECISION-26JAN-H0"  # single sub-contract: "Fed Maintains Rate" — not the whole event

kalshi_window_start = datetime.datetime(2026, 1, 1, tzinfo=datetime.timezone.utc)
kalshi_window_end = datetime.datetime(2026, 1, 14, tzinfo=datetime.timezone.utc)

kalshi_snapshot = kalshi_client.get_candlesticks(
    KALSHI_TICKER, kalshi_window_start, kalshi_window_end, period_interval=60
)
print(f"{len(kalshi_snapshot)} rows, {kalshi_snapshot.index.min()} to {kalshi_snapshot.index.max()}")

# --- 24-hour sample (Jan 1), drawn from the same series as the 14-day panel below ---
sample = kalshi_snapshot.iloc[:24]

display(Markdown("#### Kalshi Price & Volume Charts"))

fig = plt.figure(figsize=(11, 10))
gs = fig.add_gridspec(3, 1, height_ratios=[1.3, 2, 1], hspace=0.5)
ax_14d = fig.add_subplot(gs[0])
ax_price = fig.add_subplot(gs[1])
ax_vol = fig.add_subplot(gs[2], sharex=ax_price)

# --- Top: 14-day yes_ask (Quick Order / "Quick Buy") price ---
ax_14d.plot(kalshi_snapshot.index, kalshi_snapshot["yes_ask"], color="darkorange", linewidth=1.2)
ax_14d.tick_params(axis="x", rotation=30)
ax_14d.set_title(
    f'{KALSHI_TICKER}  —  "Fed Maintains Rate" — 14-Day Quick Order (yes_ask) Price\n'
    f"Hourly ticks, {kalshi_window_start.date()} to {kalshi_window_end.date()}",
    fontsize=11,
)
ax_14d.set_ylabel("yes_ask ($)")

# --- Middle: 24-hour yes_ask price, same series zoomed into Jan 1 ---
ax_price.plot(range(len(sample)), sample["yes_ask"], color="darkorange", linewidth=1.4, marker="o", markersize=3)
ax_price.set_title(
    f'{KALSHI_TICKER}  —  "Fed Maintains Rate" contract only, one of five outcomes for this event\n'
    f"24-Hour Quick Order (yes_ask) Price, hourly ticks, {sample.index[0].date()} 00:00–23:00 UTC",
    fontsize=11,
)
ax_price.set_ylabel("yes_ask ($)")

# --- Bottom: 24-hour volume, aligned with the price panel's time axis ---
vol_bars = ax_vol.bar(range(len(sample)), sample["volume"], color="darkorange")
ax_vol.bar_label(vol_bars, fmt="{:,.0f}", fontsize=6, rotation=90, padding=2)
ax_vol.set_ylabel("volume")
ax_vol.set_xticks(range(len(sample)))
ax_vol.set_xticklabels([ts.strftime("%H:%M") for ts in sample.index], rotation=45, ha="right")

plt.tight_layout()
plt.show()

# --- Schema table: what's in kalshi_snapshot today, what Kalshi's raw    ---
# --- candlestick schema also offers but we don't pull, and what isn't   ---
# --- available from this endpoint at all.                               ---
schema_table = pd.DataFrame(
    [
        {"Field": "timestamp", "Brief Description": "End time of each hourly bar; the index everything else joins on.", "% Relevant to KPIs": 100, "Currently Ingested?": "Yes"},
        {"Field": "price", "Brief Description": "Trade price at bar close, falling back to the bid/ask midpoint if no trade occurred that hour. The core value behind Gross Spread and Net Edge.", "% Relevant to KPIs": 100, "Currently Ingested?": "Yes"},
        {"Field": "price_source", "Brief Description": "Flags whether price came from an actual trade or a bid/ask-midpoint fallback — a confidence signal on that bar's price.", "% Relevant to KPIs": 60, "Currently Ingested?": "Yes"},
        {"Field": "yes_bid", "Brief Description": "Best available price to sell \"Yes\" at bar close — one side of the quoted spread.", "% Relevant to KPIs": 90, "Currently Ingested?": "Yes"},
        {"Field": "yes_ask", "Brief Description": "The Quick Order (\"Buy Now\") price — the best available price to instantly buy \"Yes\" at bar close by taking liquidity rather than waiting on a limit order. Paired with yes_bid, this is our Order Book Depth & Slippage proxy.", "% Relevant to KPIs": 90, "Currently Ingested?": "Yes"},
        {"Field": "volume", "Brief Description": "Number of contracts traded during the bar — directly the Market Volume KPI.", "% Relevant to KPIs": 100, "Currently Ingested?": "Yes"},
        {"Field": "open_interest", "Brief Description": "Total contracts currently outstanding (not yet settled) — a liquidity signal, but not one of our named KPIs.", "% Relevant to KPIs": 25, "Currently Ingested?": "Yes"},
        {"Field": "no_bid / no_ask", "Brief Description": "Best prices to sell/buy \"No\" instead of \"Yes.\" Not returned by the candlesticks endpoint (confirmed) — but always derivable, since Yes and No are complementary sides of the same contract: no_bid = $1 − yes_ask, no_ask = $1 − yes_bid. Only worth pulling directly if we ever trade the No side explicitly.", "% Relevant to KPIs": 15, "Currently Ingested?": "No — derivable, not a separate field"},
        {"Field": "yes_bid_size_fp / yes_ask_size_fp", "Brief Description": "The number of contracts actually available at the best bid/ask — not just the price. This is the real gap in our current Depth & Slippage proxy, which only uses price width; size tells us how much could actually be filled before the price moves. Only available as a live/current-snapshot value on the metadata endpoint, not as a historical time series.", "% Relevant to KPIs": 70, "Currently Ingested?": "No — metadata endpoint, snapshot only, no history"},
        {"Field": "price_open / high / low", "Brief Description": "Trade price range within the bar. Available via kalshi_client.get_candlesticks_raw() (used earlier to inspect the schema) but not pulled here, now that the chart uses yes_ask alone rather than a candlestick. Would sharpen Time-to-Convergence at finer granularity.", "% Relevant to KPIs": 40, "Currently Ingested?": "No — available, not pulled"},
        {"Field": "price_mean", "Brief Description": "Kalshi-computed average trade price for the bar — an alternate \"typical price\" to close.", "% Relevant to KPIs": 20, "Currently Ingested?": "No — available, not pulled"},
        {"Field": "price_previous", "Brief Description": "Last known trade price carried over from the prior bar when this bar had none — a continuity/convenience field.", "% Relevant to KPIs": 10, "Currently Ingested?": "No — available, not pulled"},
        {"Field": "yes_bid / yes_ask open / high / low", "Brief Description": "Intrabar quote range — shows how much the spread (and the Quick Order price) moved within the hour, not just at bar-close.", "% Relevant to KPIs": 40, "Currently Ingested?": "No — available, not pulled"},
        {"Field": "Number of trades / per-trade size / taker side", "Brief Description": "Not returned by the candlesticks endpoint. Confirmed available (public, no auth) from Kalshi's separate /historical/trades endpoint: individual trade_id, contract count, yes/no price, and taker side per trade — the real source for trade count and trade-size distribution, not just aggregate volume.", "% Relevant to KPIs": 60, "Currently Ingested?": "No — different endpoint"},
        {"Field": "is_block_trade", "Brief Description": "Flags trades that were privately negotiated as a block rather than filled against the visible order book. Matters if we ever lean on trade volume as a depth signal, since block trades bypass normal book depth entirely.", "% Relevant to KPIs": 35, "Currently Ingested?": "No — different endpoint (/historical/trades)"},
    ]
)

pd.set_option("display.max_colwidth", None)
schema_table_styled = (
    schema_table.style
    .hide(axis="index")
    .set_properties(**{"text-align": "left", "white-space": "normal", "vertical-align": "top", "padding": "10px"})
    .set_properties(subset=["Brief Description"], **{"min-width": "480px"})
    .set_properties(subset=["Field"], **{"min-width": "220px", "font-weight": "600"})
    .set_table_styles(
        [
            {"selector": "table", "props": [("width", "100%"), ("table-layout", "fixed")]},
            {"selector": "th", "props": [("text-align", "left"), ("background-color", "#f0f0f0"), ("padding", "10px")]},
        ]
    )
)

display(Markdown("#### Kalshi Data Schema — Field Reference"))
display(schema_table_styled)

313 rows, 2026-01-01 00:00:00+00:00 to 2026-01-14 00:00:00+00:00

C:\Users\mesim\AppData\Local\Temp\ipykernel_36668\3155026977.py:50: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.
  plt.tight_layout()

kalshi_markets_meta = kalshi_client.get_historical_markets("KXFEDDECISION-26JAN")
kalshi_h0_meta = next(m for m in kalshi_markets_meta if m["ticker"] == KALSHI_TICKER)

display(Markdown(f"**Primary rule:** {kalshi_h0_meta['rules_primary']}"))
display(Markdown(f"**Secondary rule:** {kalshi_h0_meta['rules_secondary']}"))

polymarket_event = polymarket_client.get_event_by_slug("fed-decision-in-january")

polymarket_full_event_data = {}
for market in polymarket_event["markets"]:
    token_id = market_matching._polymarket_yes_token(market)
    market_start = pd.to_datetime(market["startDate"], utc=True)
    market_end = pd.to_datetime(market["closedTime"], utc=True)
    polymarket_full_event_data[market["slug"]] = polymarket_client.get_prices_history(
        token_id, market_start, market_end, fidelity=1
    )

polymarket_market = next(m for m in polymarket_event["markets"] if "No change" in m["question"])

polymarket_window_start = datetime.datetime(2026, 1, 1, tzinfo=datetime.timezone.utc)
polymarket_window_end = datetime.datetime(2026, 1, 14, tzinfo=datetime.timezone.utc)

# Sliced from polymarket_full_event_data (fidelity=1) rather than a separate
# fetch, then resampled to hourly to match the stated 1-hour-tick sample.
polymarket_snapshot = (
    polymarket_full_event_data[polymarket_market["slug"]]
    .loc[polymarket_window_start:polymarket_window_end]
    .resample("1h")
    .last()
    .dropna()
)
print(f"{len(polymarket_snapshot)} rows, {polymarket_snapshot.index.min()} to {polymarket_snapshot.index.max()}")
print(f"actual granularity: {polymarket_client.actual_granularity_seconds(polymarket_snapshot):.0f}s")

# --- 14-day price history. No OHLC or volume exist for this endpoint, so ---
# --- unlike the Kalshi candlestick chart, this is a plain price line.    ---
display(Markdown("#### 14-Day Price History"))

fig, ax = plt.subplots(figsize=(11, 4.5))
ax.plot(polymarket_snapshot.index, polymarket_snapshot["price"], color="steelblue", linewidth=1.2)
ax.set_title(
    'Polymarket — "No change in Fed interest rates after January 2026 meeting?" (Yes)\n'
    f"Hourly ticks, {polymarket_window_start.date()} to {polymarket_window_end.date()}",
    fontsize=11,
)
ax.set_ylabel("price ($)")
plt.tight_layout()
plt.show()

# --- 24-hour sample, January 1st: price (hourly, from the full ingest)   ---
# --- and volume (hourly-summed trade size, from the separate trades      ---
# --- endpoint — prices-history itself has no volume field at all).      ---
polymarket_24h_start = datetime.datetime(2026, 1, 1, tzinfo=datetime.timezone.utc)
polymarket_24h_end = datetime.datetime(2026, 1, 2, tzinfo=datetime.timezone.utc)
polymarket_24h_index = pd.date_range(polymarket_24h_start, periods=24, freq="1h", tz="UTC")

polymarket_24h_price = (
    polymarket_full_event_data[polymarket_market["slug"]]
    .loc[polymarket_24h_start:polymarket_24h_end]
    .resample("1h")
    .last()
    .reindex(polymarket_24h_index)
)

polymarket_24h_trades = polymarket_client.get_trades(
    polymarket_market["conditionId"], polymarket_24h_start, polymarket_24h_end
)
polymarket_24h_volume = (
    polymarket_24h_trades["size"].resample("1h").sum().reindex(polymarket_24h_index, fill_value=0)
)

display(Markdown("#### 24-Hour Sample — January 1, 2026"))

fig = plt.figure(figsize=(16, 6.5))
gs = fig.add_gridspec(2, 1, height_ratios=[2, 1], hspace=0.15)
ax_24h_price = fig.add_subplot(gs[0])
ax_24h_vol = fig.add_subplot(gs[1], sharex=ax_24h_price)

ax_24h_price.plot(range(24), polymarket_24h_price["price"], color="steelblue", marker="o", markersize=3, linewidth=1.2)
ax_24h_price.set_title(
    'Polymarket — "No change in Fed interest rates after January 2026 meeting?" (Yes)\n'
    "Hourly ticks, January 1, 2026",
    fontsize=11,
)
ax_24h_price.set_ylabel("price ($)")

vol_bars = ax_24h_vol.bar(range(24), polymarket_24h_volume, color="steelblue")
ax_24h_vol.bar_label(vol_bars, fmt="{:,.0f}", fontsize=6, rotation=90, padding=2)
ax_24h_vol.set_ylabel("volume (contracts)")
ax_24h_vol.set_xticks(range(24))
ax_24h_vol.set_xticklabels([ts.strftime("%H:%M") for ts in polymarket_24h_index], rotation=45, ha="right")

plt.tight_layout()
plt.show()

# --- Schema table: what prices-history actually returns, and what it    ---
# --- doesn't — for direct comparison against the Kalshi schema table.   ---
polymarket_schema_table = pd.DataFrame(
    [
        {"Field": "timestamp (t)", "Brief Description": "Time of each price point. Points land at irregular sub-minute offsets even with fidelity=60 requested (e.g. 00:00:20, 01:00:16) rather than a clean hourly grid — worth noting before merge_asof-aligning against Kalshi's clean hourly bars.", "% Relevant to KPIs": 100, "Currently Ingested?": "Yes", "Also in Kalshi?": "Y"},
        {"Field": "price (p)", "Brief Description": "The single price value at that timestamp. Unlike Kalshi, this endpoint doesn't distinguish trade price from quote price — it's just \"the price.\" The core value behind Gross Spread and Net Edge on the Polymarket side.", "% Relevant to KPIs": 100, "Currently Ingested?": "Yes", "Also in Kalshi?": "Y"},
        {"Field": "bid / ask", "Brief Description": "Not returned by prices-history. The Gamma metadata endpoint does carry a live bestBid/bestAsk snapshot (and a computed spread field), but only as a current value, not a historical time series — same limitation as Kalshi's yes_bid_size_fp.", "% Relevant to KPIs": 90, "Currently Ingested?": "No — live snapshot only, no history", "Also in Kalshi?": "Y"},
        {"Field": "volume", "Brief Description": "Not returned by prices-history. Aggregated ourselves above from individual trade sizes via the /trades endpoint; Gamma metadata also has lifetime and rolling-window totals (volume, volume1wk, volume1mo, volume1yr) but no per-bar time series.", "% Relevant to KPIs": 100, "Currently Ingested?": "Partial — derived from /trades, not a native field", "Also in Kalshi?": "Y"},
        {"Field": "open_interest", "Brief Description": "Not offered anywhere in Polymarket's public API — no equivalent field exists on the Gamma market metadata or any other endpoint checked.", "% Relevant to KPIs": 25, "Currently Ingested?": "No — not offered by Polymarket at all", "Also in Kalshi?": "Y"},
        {"Field": "price_mean (bar aggregate)", "Brief Description": "Not offered. Polymarket has no candle/bar aggregation endpoint at all — prices-history returns raw point-in-time ticks only, never an averaged price over an interval the way Kalshi's price.mean does.", "% Relevant to KPIs": 20, "Currently Ingested?": "No — not offered by Polymarket at all", "Also in Kalshi?": "Y"},
        {"Field": "number of trades / per-trade size", "Brief Description": "Confirmed available: the public, unauthenticated data-api.polymarket.com/trades endpoint returns individual trade records (price, size, timestamp, BUY/SELL side, wallet, on-chain transactionHash) — used directly above to build the volume bar chart.", "% Relevant to KPIs": 60, "Currently Ingested?": "Yes — via get_trades()", "Also in Kalshi?": "Y"},
        {"Field": "is_block_trade", "Brief Description": "Not present in the documented /trades response schema. No confirmed Polymarket equivalent to Kalshi's block-trade flag.", "% Relevant to KPIs": 35, "Currently Ingested?": "No — not offered (unconfirmed to exist)", "Also in Kalshi?": "Y"},
    ]
)

polymarket_schema_table_styled = (
    polymarket_schema_table.style
    .hide(axis="index")
    .set_properties(**{"text-align": "left", "white-space": "normal", "vertical-align": "top", "padding": "10px"})
    .set_properties(subset=["Brief Description"], **{"min-width": "480px"})
    .set_properties(subset=["Field"], **{"min-width": "220px", "font-weight": "600"})
    .set_table_styles(
        [
            {"selector": "table", "props": [("width", "100%"), ("table-layout", "fixed")]},
            {"selector": "th", "props": [("text-align", "left"), ("background-color", "#f0f0f0"), ("padding", "10px")]},
        ]
    )
)

display(Markdown("#### Polymarket Data Schema — Field Reference"))
display(polymarket_schema_table_styled)

312 rows, 2026-01-01 00:00:00+00:00 to 2026-01-13 23:00:00+00:00
actual granularity: 3600s

C:\Users\mesim\AppData\Local\Temp\ipykernel_36668\1382377688.py:76: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.
  plt.tight_layout()

display(Markdown(f"**Description / resolution criteria:** {polymarket_market['description']}"))

overlay_start = datetime.datetime(2026, 1, 1, tzinfo=datetime.timezone.utc)
overlay_end = datetime.datetime(2026, 1, 14, tzinfo=datetime.timezone.utc)

kalshi_overlay = kalshi_full_event_data[KALSHI_TICKER].loc[overlay_start:overlay_end]
polymarket_overlay = polymarket_full_event_data[polymarket_market["slug"]].loc[overlay_start:overlay_end]

display(Markdown("#### 14-Day Price History — Kalshi vs. Polymarket, Overlaid"))

fig, ax = plt.subplots(figsize=(16, 5))
ax.plot(kalshi_overlay.index, kalshi_overlay["yes_ask"], color="red", linewidth=0.8, label="Kalshi (yes_ask / Quick Buy)")
ax.plot(polymarket_overlay.index, polymarket_overlay["price"], color="blue", linewidth=0.8, label="Polymarket")
ax.set_xlabel("date")
ax.set_ylabel("price ($)")
ax.set_title('"Fed Maintains Rate" / "No change" — 1-minute ticks, Jan 1–14, 2026')
ax.legend()
plt.tight_layout()
plt.show()

display(Markdown("#### Frequency of Price Change per Day — Polymarket vs. Kalshi"))

kalshi_full_price = kalshi_full_event_data[KALSHI_TICKER]["price"]
kalshi_daily_changes = (kalshi_full_price != kalshi_full_price.shift(1)).resample("1D").sum()

polymarket_full_price = polymarket_full_event_data[polymarket_market["slug"]]["price"]
polymarket_daily_changes = (polymarket_full_price != polymarket_full_price.shift(1)).resample("1D").sum()

fig, ax = plt.subplots(figsize=(16, 5))
ax.bar(polymarket_daily_changes.index, polymarket_daily_changes.values, color="blue", alpha=0.5, width=1, label="Polymarket")
ax.bar(kalshi_daily_changes.index, kalshi_daily_changes.values, color="red", alpha=0.5, width=1, label="Kalshi")
ax.set_xlabel("date")
ax.set_ylabel("frequency of price change (count/day)")
ax.set_title('"Fed Maintains Rate" / "No change" — daily count of price-change ticks, full contract lifetime')
ax.legend()
plt.tight_layout()
plt.show()

ARBITRAGE_THRESHOLD = 0.05

kalshi_full = kalshi_full_event_data[KALSHI_TICKER].reset_index().rename(
    columns={"timestamp": "ts", "yes_ask": "kalshi_yes_ask"}
)
polymarket_full = polymarket_full_event_data[polymarket_market["slug"]].reset_index().rename(
    columns={"timestamp": "ts", "price": "polymarket_price"}
)

arb_aligned = pd.merge_asof(
    kalshi_full[["ts", "kalshi_yes_ask"]].sort_values("ts"),
    polymarket_full[["ts", "polymarket_price"]].sort_values("ts"),
    on="ts",
    tolerance=pd.Timedelta("5min"),
    direction="backward",
).dropna()

arb_aligned["gross_spread"] = (arb_aligned["kalshi_yes_ask"] - arb_aligned["polymarket_price"]).abs()
arb_aligned["is_arbitrage"] = arb_aligned["gross_spread"] >= ARBITRAGE_THRESHOLD

weekly_arb_count = arb_aligned.set_index("ts")["is_arbitrage"].resample("1W").sum()

display(Markdown(f"#### Weekly Count of Arbitrage-Qualifying Minutes (Gross Spread ≥ ${ARBITRAGE_THRESHOLD:.2f})"))

fig, ax = plt.subplots(figsize=(14, 5))
weekly_bars = ax.bar(weekly_arb_count.index, weekly_arb_count.values, color="darkgreen", width=5)
ax.bar_label(weekly_bars, fmt="{:,.0f}", fontsize=8, padding=2)
ax.set_xlabel("week")
ax.set_ylabel("count of qualifying 1-minute ticks")
ax.set_title(
    f'"Fed Maintains Rate" / "No change" — weekly count of minutes with '
    f"|Kalshi yes_ask − Polymarket price| ≥ ${ARBITRAGE_THRESHOLD:.2f}"
)
plt.tight_layout()
plt.show()

print(
    f"Total qualifying minutes: {arb_aligned['is_arbitrage'].sum():,} out of {len(arb_aligned):,} "
    f"aligned minutes ({arb_aligned['is_arbitrage'].mean():.2%})"
)

Total qualifying minutes: 6,688 out of 74,872 aligned minutes (8.93%)

MIN_EVENT_DURATION_MINUTES = 5

# Group consecutive qualifying minutes into distinct episodes, then keep only
# the ones that persisted for at least MIN_EVENT_DURATION_MINUTES.
run_id = (arb_aligned["is_arbitrage"] != arb_aligned["is_arbitrage"].shift()).cumsum()
episodes = arb_aligned[arb_aligned["is_arbitrage"]].groupby(run_id)["ts"].agg(["min", "max"])
episodes["duration_minutes"] = (episodes["max"] - episodes["min"]).dt.total_seconds() / 60
qualifying_events = episodes[episodes["duration_minutes"] >= MIN_EVENT_DURATION_MINUTES]

weekly_event_count = pd.Series(1, index=qualifying_events["min"]).resample("1W").sum()

display(Markdown(
    f"#### Weekly Count of Distinct Arbitrage Events (Gross Spread ≥ ${ARBITRAGE_THRESHOLD:.2f}, "
    f"lasting ≥ {MIN_EVENT_DURATION_MINUTES} minutes)"
))

fig, ax = plt.subplots(figsize=(14, 5))
event_bars = ax.bar(weekly_event_count.index, weekly_event_count.values, color="seagreen", width=5)
ax.bar_label(event_bars, fmt="{:,.0f}", fontsize=8, padding=2)
ax.set_xlabel("week")
ax.set_ylabel("count of distinct events")
ax.set_title(
    f'"Fed Maintains Rate" / "No change" — weekly count of arbitrage episodes lasting '
    f"{MIN_EVENT_DURATION_MINUTES}+ minutes"
)
plt.tight_layout()
plt.show()

print(
    f"Total distinct arbitrage episodes: {len(episodes):,} | "
    f"lasting {MIN_EVENT_DURATION_MINUTES}+ minutes: {len(qualifying_events):,} "
    f"({len(qualifying_events) / len(episodes):.1%} of all episodes)"
)

Total distinct arbitrage episodes: 336 | lasting 5+ minutes: 80 (23.8% of all episodes)

NOV_START = datetime.datetime(2025, 11, 1, tzinfo=datetime.timezone.utc)
NOV_END = datetime.datetime(2025, 12, 1, tzinfo=datetime.timezone.utc)

BUCKETS = {
    "No Change": ("KXFEDDECISION-26JAN-H0", "no-change-in-fed-interest-rates-after-january-2026-meeting"),
    "25bps Decrease": ("KXFEDDECISION-26JAN-C25", "fed-decreases-interest-rates-by-25-bps-after-january-2026-meeting"),
    "50+bps Decrease": ("KXFEDDECISION-26JAN-C26", "fed-decreases-interest-rates-by-50-bps-after-january-2026-meeting"),
    "25bps+ Increase (imperfect match)": ("KXFEDDECISION-26JAN-H25", "fed-increases-interest-rates-by-25-bps-after-january-2026-meeting"),
}

STAT_ROWS = [
    "Average Price Divergence Per Event",
    "Average Price Divergence Per Day",
    "Median Price Divergence Per Event",
    "Average Length in Minutes of Divergence",
    "Longest Single Divergence Duration (min)",
    "Largest Price Divergence Per Day",
    "Smallest Price Divergence Per Day",
    "Average Volume Per Divergent Event",
    "Average Buy Now Price Per Divergent Event",
]


def compute_bucket_stats(kalshi_ticker, polymarket_slug, window_start, window_end, threshold=ARBITRAGE_THRESHOLD):
    k = kalshi_full_event_data[kalshi_ticker].reset_index().rename(
        columns={"timestamp": "ts", "yes_ask": "kalshi_yes_ask", "volume": "kalshi_volume"}
    )
    p = polymarket_full_event_data[polymarket_slug].reset_index().rename(
        columns={"timestamp": "ts", "price": "polymarket_price"}
    )

    aligned = pd.merge_asof(
        k[["ts", "kalshi_yes_ask", "kalshi_volume"]].sort_values("ts"),
        p[["ts", "polymarket_price"]].sort_values("ts"),
        on="ts",
        tolerance=pd.Timedelta("5min"),
        direction="backward",
    ).dropna(subset=["kalshi_yes_ask", "polymarket_price"])

    aligned = aligned[(aligned["ts"] >= window_start) & (aligned["ts"] < window_end)]
    aligned["gross_spread"] = (aligned["kalshi_yes_ask"] - aligned["polymarket_price"]).abs()
    aligned["is_arb"] = aligned["gross_spread"] >= threshold

    if aligned.empty or not aligned["is_arb"].any():
        return {stat: None for stat in STAT_ROWS}

    arb_rows = aligned[aligned["is_arb"]]
    run_id = (aligned["is_arb"] != aligned["is_arb"].shift()).cumsum()
    episodes = arb_rows.groupby(run_id).agg(
        start=("ts", "min"),
        end=("ts", "max"),
        mean_spread=("gross_spread", "mean"),
        mean_volume=("kalshi_volume", "mean"),
        mean_price=("kalshi_yes_ask", "mean"),
    )
    episodes["duration_minutes"] = (episodes["end"] - episodes["start"]).dt.total_seconds() / 60 + 1

    daily = arb_rows.set_index("ts")["gross_spread"].resample("1D")
    daily_mean, daily_max, daily_min = daily.mean().dropna(), daily.max().dropna(), daily.min().dropna()

    return {
        "Average Price Divergence Per Event": episodes["mean_spread"].mean(),
        "Average Price Divergence Per Day": daily_mean.mean(),
        "Median Price Divergence Per Event": episodes["mean_spread"].median(),
        "Average Length in Minutes of Divergence": episodes["duration_minutes"].mean(),
        "Longest Single Divergence Duration (min)": episodes["duration_minutes"].max(),
        "Largest Price Divergence Per Day": daily_max.mean(),
        "Smallest Price Divergence Per Day": daily_min.mean(),
        "Average Volume Per Divergent Event": episodes["mean_volume"].mean(),
        "Average Buy Now Price Per Divergent Event": episodes["mean_price"].mean(),
    }


results = {
    bucket_name: compute_bucket_stats(k_ticker, p_slug, NOV_START, NOV_END)
    for bucket_name, (k_ticker, p_slug) in BUCKETS.items()
}
stats_table = pd.DataFrame(results).loc[STAT_ROWS]

price_rows = [
    "Average Price Divergence Per Event",
    "Average Price Divergence Per Day",
    "Median Price Divergence Per Event",
    "Largest Price Divergence Per Day",
    "Smallest Price Divergence Per Day",
    "Average Buy Now Price Per Divergent Event",
]
duration_rows = ["Average Length in Minutes of Divergence", "Longest Single Divergence Duration (min)"]
volume_rows = ["Average Volume Per Divergent Event"]

styled_stats_table = (
    stats_table.style
    .format("${:.4f}", subset=pd.IndexSlice[price_rows, :], na_rep="N/A")
    .format("{:.1f} min", subset=pd.IndexSlice[duration_rows, :], na_rep="N/A")
    .format("{:,.0f}", subset=pd.IndexSlice[volume_rows, :], na_rep="N/A")
    .set_properties(**{"text-align": "center", "padding": "10px"})
    .set_table_styles(
        [
            {"selector": "table", "props": [("width", "100%")]},
            {"selector": "th", "props": [("text-align", "center"), ("background-color", "#f0f0f0"), ("padding", "10px")]},
            {"selector": "th.row_heading", "props": [("text-align", "left")]},
        ]
    )
)

display(Markdown("#### November Baseline Arbitrage Statistics, by Outcome Bucket"))
display(styled_stats_table)

	No Change	25bps Decrease	50+bps Decrease	25bps+ Increase (imperfect match)
Average Price Divergence Per Event	$0.0577	$0.0644	$0.0542	N/A
Average Price Divergence Per Day	$0.0699	$0.0863	$0.0572	N/A
Median Price Divergence Per Event	$0.0550	$0.0575	$0.0530	N/A
Average Length in Minutes of Divergence	65.9 min	100.5 min	136.0 min	N/A
Longest Single Divergence Duration (min)	3426.0 min	1939.0 min	2830.0 min	N/A
Largest Price Divergence Per Day	$0.0989	$0.1145	$0.0646	N/A
Smallest Price Divergence Per Day	$0.0535	$0.0636	$0.0524	N/A
Average Volume Per Divergent Event	3	2	0	N/A
Average Buy Now Price Per Divergent Event	$0.5932	$0.4010	$0.0928	N/A

Prediction Market Arbitrage Feasibility Study¶

1. INTRODUCTION¶

Document Goal¶

Arbitrage Strategy¶

Purpose of this Document¶

Procedure¶

Setting Notebook Environment¶

Example Markets to Evaluate¶

2. MARKET DISCOVERY¶

Kalshi Snapshot Ingest¶

Kalshi Price & Volume Charts¶

Kalshi Data Schema — Field Reference¶

Rules¶

Contract Data¶

Kalshi Summary¶

Polymarket Snapshot Ingest¶

14-Day Price History¶

24-Hour Sample — January 1, 2026¶

Polymarket Data Schema — Field Reference¶

Rules¶

Contract Data¶

Polymarket Flat Price¶

Polymarket Summary¶

3. Initial Arbitrage Alignment¶

Market Price Overlay¶

14-Day Price History — Kalshi vs. Polymarket, Overlaid¶

Frequency of Price Change per Day — Polymarket vs. Kalshi¶

4. Conclusion¶

5. Complete Event Contract Arbitrage Events¶

Weekly Count of Arbitrage-Qualifying Minutes (Gross Spread ≥ $0.05)¶

Weekly Count of Distinct Arbitrage Events (Gross Spread ≥ $0.05, lasting ≥ 5 minutes)¶

6. Additional Calculations¶

November Baseline Arbitrage Statistics, by Outcome Bucket¶

7. Volume Exploration¶

Field	Brief Description	% Relevant to KPIs	Currently Ingested?
timestamp	End time of each hourly bar; the index everything else joins on.	100	Yes
price	Trade price at bar close, falling back to the bid/ask midpoint if no trade occurred that hour. The core value behind Gross Spread and Net Edge.	100	Yes
price_source	Flags whether price came from an actual trade or a bid/ask-midpoint fallback — a confidence signal on that bar's price.	60	Yes
yes_bid	Best available price to sell "Yes" at bar close — one side of the quoted spread.	90	Yes
yes_ask	The Quick Order ("Buy Now") price — the best available price to instantly buy "Yes" at bar close by taking liquidity rather than waiting on a limit order. Paired with yes_bid, this is our Order Book Depth & Slippage proxy.	90	Yes
volume	Number of contracts traded during the bar — directly the Market Volume KPI.	100	Yes
open_interest	Total contracts currently outstanding (not yet settled) — a liquidity signal, but not one of our named KPIs.	25	Yes
no_bid / no_ask	Best prices to sell/buy "No" instead of "Yes." Not returned by the candlesticks endpoint (confirmed) — but always derivable, since Yes and No are complementary sides of the same contract: no_bid = $1 − yes_ask, no_ask = $1 − yes_bid. Only worth pulling directly if we ever trade the No side explicitly.	15	No — derivable, not a separate field
yes_bid_size_fp / yes_ask_size_fp	The number of contracts actually available at the best bid/ask — not just the price. This is the real gap in our current Depth & Slippage proxy, which only uses price width; size tells us how much could actually be filled before the price moves. Only available as a live/current-snapshot value on the metadata endpoint, not as a historical time series.	70	No — metadata endpoint, snapshot only, no history
price_open / high / low	Trade price range within the bar. Available via kalshi_client.get_candlesticks_raw() (used earlier to inspect the schema) but not pulled here, now that the chart uses yes_ask alone rather than a candlestick. Would sharpen Time-to-Convergence at finer granularity.	40	No — available, not pulled
price_mean	Kalshi-computed average trade price for the bar — an alternate "typical price" to close.	20	No — available, not pulled
price_previous	Last known trade price carried over from the prior bar when this bar had none — a continuity/convenience field.	10	No — available, not pulled
yes_bid / yes_ask open / high / low	Intrabar quote range — shows how much the spread (and the Quick Order price) moved within the hour, not just at bar-close.	40	No — available, not pulled
Number of trades / per-trade size / taker side	Not returned by the candlesticks endpoint. Confirmed available (public, no auth) from Kalshi's separate /historical/trades endpoint: individual trade_id, contract count, yes/no price, and taker side per trade — the real source for trade count and trade-size distribution, not just aggregate volume.	60	No — different endpoint
is_block_trade	Flags trades that were privately negotiated as a block rather than filled against the visible order book. Matters if we ever lean on trade volume as a depth signal, since block trades bypass normal book depth entirely.	35	No — different endpoint (/historical/trades)

Field	Brief Description	% Relevant to KPIs	Currently Ingested?	Also in Kalshi?
timestamp (t)	Time of each price point. Points land at irregular sub-minute offsets even with fidelity=60 requested (e.g. 00:00:20, 01:00:16) rather than a clean hourly grid — worth noting before merge_asof-aligning against Kalshi's clean hourly bars.	100	Yes	Y
price (p)	The single price value at that timestamp. Unlike Kalshi, this endpoint doesn't distinguish trade price from quote price — it's just "the price." The core value behind Gross Spread and Net Edge on the Polymarket side.	100	Yes	Y
bid / ask	Not returned by prices-history. The Gamma metadata endpoint does carry a live bestBid/bestAsk snapshot (and a computed spread field), but only as a current value, not a historical time series — same limitation as Kalshi's yes_bid_size_fp.	90	No — live snapshot only, no history	Y
volume	Not returned by prices-history. Aggregated ourselves above from individual trade sizes via the /trades endpoint; Gamma metadata also has lifetime and rolling-window totals (volume, volume1wk, volume1mo, volume1yr) but no per-bar time series.	100	Partial — derived from /trades, not a native field	Y
open_interest	Not offered anywhere in Polymarket's public API — no equivalent field exists on the Gamma market metadata or any other endpoint checked.	25	No — not offered by Polymarket at all	Y
price_mean (bar aggregate)	Not offered. Polymarket has no candle/bar aggregation endpoint at all — prices-history returns raw point-in-time ticks only, never an averaged price over an interval the way Kalshi's price.mean does.	20	No — not offered by Polymarket at all	Y
number of trades / per-trade size	Confirmed available: the public, unauthenticated data-api.polymarket.com/trades endpoint returns individual trade records (price, size, timestamp, BUY/SELL side, wallet, on-chain transactionHash) — used directly above to build the volume bar chart.	60	Yes — via get_trades()	Y
is_block_trade	Not present in the documented /trades response schema. No confirmed Polymarket equivalent to Kalshi's block-trade flag.	35	No — not offered (unconfirmed to exist)	Y