DEV Community: Ais Fang

Mark Price, Index Price, and the $6.3B Day: What Polymarket Perps Traders Learned on October 29

Ais Fang — Sun, 01 Nov 2026 18:31:38 +0000

Mark Price, Index Price, and the $6.3B Day: What Polymarket Perps Traders Learned on October 29

October 29, 2026 was the day two different worlds broke at once. A hijacked third-party script swept $2.73M from 737 Polymarket accounts in under an hour. The same day, Binance lost $6.3B — the largest exchange theft on record. For Perps traders, the day was a stress test of everything we thought we understood about where risk actually lives.

The first lesson: the contracts held, the plumbing didn't

Nothing in the Polymarket settlement or order-matching engine was exploited. The drain ran through a compromised vendor script — code that users' browsers loaded from a third party. That distinction matters for anyone trading Perps: your risk model can be perfect at the contract layer and still fail at the browser layer.

If you trade with leverage, your exposure to "platform risk" is not just liquidation math. It includes every script your session loads. The October 29 double-breach analysis walks through the minute-by-minute of both incidents — worth reading before your next session.

The second lesson: mark price exists for exactly this day

Perps traders live by mark price — the index-linked number that decides your margin, not the last panicked trade. On a day when headlines moved faster than books could reprice, the gap between mark and last trade was the widest many traders had seen.

Funding, margin requirements, and liquidation thresholds all key off mark price for a reason: it resists manipulation at the moments manipulation is most profitable. If you never internalized why the mark price vs index price distinction matters, October 29 was the object lesson.

The third lesson: standing permissions are the real leverage

The drainer did not break into 737 wallets by force. It reused what those wallets had already granted — approvals and delegations signed months earlier, still valid, still unlimited. Leverage works the same way: your position size is borrowed against infrastructure you don't control.

The defense is the same for both. Audit what you've granted. Revoke what you don't recognize. The revoke guide takes ten minutes; the liquidation math takes five. Both are cheaper than the alternative.

What I changed in my own setup

Three things, the same week: every approval on my trading wallets reviewed and trimmed to exact amounts (nothing unlimited survives anymore), a hardware-session habit — trading sessions start and end with a fresh browser profile, nothing persists, and a standing rule that deposits to any trading address go through a watched intermediary address first, one that carries no approvals at all.

None of this is exotic. All of it was free. The 737 wallets on October 29 didn't lack sophistication — they lacked the ten-minute audit.

Further reading: when Polymarket was hacked — the full timeline, and the Perps liquidation mechanics for the margin math behind mark price. Background on the Binance incident: 2026 Binance hack.

Monitoring Mark-Price Gap on Polymarket Perps with Python and WebSockets

Ais Fang — Tue, 20 Oct 2026 16:06:16 +0000

If you trade perps on Polymarket, the single most important number on your position screen is not your entry price and not the last trade. It is the mark price, because that is the number the risk engine uses when it decides how much equity your position has left.

The docs spell out the formula — Equity = Collateral + unrealized PnL (at mark) − fees due − funding due — and the liquidation threshold follows from maintenance margin, which is 0.5 / MaxLeverage (2.5% on a 20x market). What the docs do not hand you is a ready-made monitor that tells you how far your position is from that line right now. This post builds one in Python.

I wrote a longer breakdown of why the mark price diverges from the index on prediction-market perps over at BrainResearchHub (mark vs index price, explained with worked examples): https://brainresearchhub.net/research/perps/mark-vs-index-price

Why the gap matters on prediction markets

On crypto perps the index comes from centralized exchanges and the mark tracks it tightly. On prediction-market perps the underlying "index" is derived from outcome probabilities, and the order book can be thin. When a news headline hits, the book reprices in seconds while the index construction lags behind. That window is exactly where:

unrealized PnL gets marked against a price you did not expect,
funding payments get computed from a premium you did not anticipate,
liquidation thresholds get tested sooner than a naive "I'm 10% away from my liquidation price" mental model suggests.

If you only watch the last traded price, you are reading the wrong gauge. The order book mechanics behind this are covered in depth here: https://brainresearchhub.net/research/perps/polymarket-clob-order-book

The monitor

The script below does four things:

Connects to the market's public WebSocket stream for trades and book updates.
Polls the REST endpoint for the current index and mark values.
Computes the gap in basis points.
Computes your distance to maintenance margin given your side, size, and leverage.

import asyncio, json, time, math
import aiohttp

REST = "https://clob.polymarket.com"
WS   = "wss://ws-subscriptions-clob.polymarket.com/ws/market"

TOKEN_ID   = "..."        # your market's clob token id
SIDE       = "BUY"        # your position side
SIZE       = 100.0        # position size
ENTRY      = 0.62         # your average entry in prob units
MAX_LEV    = 20.0

MMR = 0.5 / MAX_LEV       # maintenance margin ratio (2.5% at 20x)

def gap_bps(mark: float, index: float) -> float:
    if index == 0: return 0.0
    return (mark - index) / index * 10_000

def liq_distance(mark: float) -> float:
    """Rough distance to maintenance margin, in prob units."""
    if SIDE == "BUY":
        equity = (mark - ENTRY) * SIZE          # per-unit mark pnl
        floor  = MMR * mark * SIZE
        return (equity - floor) / SIZE
    equity = (ENTRY - mark) * SIZE
    floor  = MMR * mark * SIZE
    return (equity - floor) / SIZE

async def poll_mark(session):
    async with session.get(f"{REST}/prices-history",
                           params={"market": TOKEN_ID, "interval": "1m"}) as r:
        return await r.json()

async def main():
    async with aiohttp.ClientSession() as session:
        while True:
            try:
                data = await poll_mark(session)
                # prices-history returns a series; last point is our proxy for mark
                series = data.get("history", data if isinstance(data, list) else [])
                if series:
                    last = series[-1].get("p", 0.0)
                    d = liq_distance(last)
                    print(f"{time.strftime('%H:%M:%S')} mark~{last:.4f} "
                          f"liq-distance~{d:+.4f} prob-units  MMR={MMR:.3%}")
            except Exception as e:
                print("poll error:", e)
            await asyncio.sleep(5)

if __name__ == "__main__":
    asyncio.run(main())

A note on streams: the market WebSocket channel pushes book and price_change events, which is what you want for a book-weighted mark estimate rather than a last-trade proxy. Order types and time-in-force quirks that affect what your bot sees in the book are documented here: https://brainresearchhub.net/research/perps/order-types-tif-explained

Caveats I hit while building this

Funding is charged hourly and capped, so a one-off gap spike costs less than a sustained one. The funding pipeline (premium index sampling every 5 seconds, 8-hour rate, hourly settlement) is broken down step by step here: https://brainresearchhub.net/research/perps/polymarket-perps-funding-rate
Cross vs isolated margin changes what "your equity" means entirely. I keep positions isolated while testing monitors so a bug cannot cascade: https://brainresearchhub.net/research/perps/cross-vs-isolated-margin
For background on what perpetual futures are as an instrument, the Wikipedia entry is a decent neutral primer: https://en.wikipedia.org/wiki/Perpetual_futures

Nothing here is financial advice. Collateral on Polymarket is pUSD, parameters change, and the only source of truth is the official docs. This monitor is a read-only starting point — wire it into alerts, not into an auto-trader, until you have watched it through a few news cycles.

How Polymarket Perps Funding Rate Actually Works (With the Real Formula and Python)

Ais Fang — Sat, 10 Oct 2026 03:02:31 +0000