Market Making in Prediction Markets: A Learning Journal
Market Making on Polymarket
Personal notes compiled while researching Polymarket's order book mechanics
Overview
This document captures my learning journey into market making on Polymarket, building on my derivatives product background. Focus is on the Central Limit Order Book (CLOB) architecture.
1. Market Categories Analysis
Volume Distribution by Category
| Category | % of Volume | Key Characteristics |
|---|---|---|
| Sports | ~39% | Short resolution, high frequency, official partnerships |
| Politics | ~34% | High liquidity on majors, long duration, information asymmetry |
| Crypto | ~18% | 24/7 markets, correlated to crypto sentiment |
| Economics | ~5% | Fed decisions, macro events, institutional interest |
| Culture/Entertainment | ~4% | Box office, awards, unpredictable |
Top Markets by Volume (Jan 2026)
| Market | Volume | Category |
|---|---|---|
| Super Bowl Champion 2026 | $654M | Sports/NFL |
| Democratic Presidential Nominee 2028 | $440M | Politics |
| Presidential Election Winner 2028 | $172M | Politics |
| UEFA Champions League Winner | $166M | Sports |
| English Premier League Winner | $156M | Sports |
| Fed decision in January? | $156M | Economics |
| 2026 NBA Champion | $140M | Sports |
Official Sports Partnerships
- UFC - Exclusive prediction market partner, real-time Fan Prediction Scoreboard
- NHL - First major U.S. league to partner, logo/branding rights
Category Comparison for Market Making
| Factor | Sports | Politics | Crypto | Economics |
|---|---|---|---|---|
| Resolution Time | Hours-Weeks | Months-Years | Variable | Days-Weeks |
| Information Edge | Fast data feeds | Polling/insider | On-chain data | Macro analysis |
| Toxic Flow Risk | HIGH (live events) | MEDIUM (leaks) | MEDIUM | LOW |
| Capital Turnover | FAST | SLOW | MEDIUM | MEDIUM |
| Liquidity | Deep on majors | Very deep on elections | Moderate | Growing |
| Volatility Pattern | Spikes at game time | Gradual + event spikes | Follows crypto | Event-driven |
Key Insight: Toxic Flow Problem
Sports markets have the highest toxic flow risk:
- Bettors at live events can bet immediately when something happens
- Market makers get picked off before odds adjust
- Sportsbooks solve this with betting delays (not available on Polymarket)
Politics has adverse selection:
- Insiders may have weeks/months of information advantage
- Polling leaks, campaign insider knowledge
Recommendation: For market making, consider:
- Economics/Fed - Lower toxic flow, predictable event timing
- Sports (non-live) - Futures markets before games start
- Multi-outcome markets - More complexity = less competition
2. Polymarket Architecture
Hybrid-Decentralized Model
Polymarket uses a hybrid-decentralized CLOB:
| Component | Location | Responsibility |
|---|---|---|
| Order matching | Off-chain | Operator matches orders |
| Settlement | On-chain | Atomic swaps via smart contracts |
| Order signing | Client-side | EIP-712 signed structured data |
Key Insight
Orders stay off-chain until execution—users can update or cancel without on-chain transactions. The operator's privileges are limited to matching and sequencing; they cannot set prices or execute unauthorized trades.
3. Core Smart Contracts
CTFExchange.sol
The main exchange contract facilitating atomic swaps between:
- Outcome Tokens: ERC-1155 tokens (via Gnosis Conditional Token Framework)
- Collateral: ERC-20 (USDC)
Token Relationship
A + A' = C
Where:
A = YES outcome token
A' = NO outcome token
C = Collateral (USDC)
This relationship enables three matching scenarios:
| Scenario | Description | What Happens |
|---|---|---|
| NORMAL | Direct swap | Tokens/collateral transfer between parties |
| MINT | Complementary buy orders match | System mints A + A' from collateral |
| MERGE | Complementary sell orders match | System merges A + A' back to collateral |
Contract Repositories
- Polymarket/ctf-exchange - Main exchange contract
- Polymarket/neg-risk-ctf-adapter - Multi-outcome market adapter
4. Order Structure
Orders are EIP-712 signed structured data:
- One maker per matched order
- One or more takers
- Price improvements benefit the taker
Signature Types
| Type | Value | Use Case |
|---|---|---|
| EOA | 0 | Standard wallet signatures |
| Magic/Email | 1 | Email wallet signatures |
| Proxy | 2 | Browser wallet proxy signatures |
5. Fee Structure
Current State
Zero fees across all volume levels (subject to change).
Fee Formula (When Active)
Fees are symmetric to preserve market integrity:
feeQuote = baseRate × min(price, 1-price) × size
Example at baseRate = 0.02, price = $0.50:
- Buying 100 YES @ $0.50 → 1 USDC fee
- Selling 100 NO @ $0.50 → 1 USDC fee
The min(price, 1-price) ensures someone selling YES @ $0.99 pays the same as someone buying NO @ $0.01.
6. Official Market Maker Implementation
Polymarket provides an open-source market maker: poly-market-maker
How It Works
Sync cycle every 30 seconds (configurable):
- Fetch current midpoint from CLOB
- Calculate target order positions
- Compare intended vs existing orders
- Cancel stale orders
- Place new orders
Two Strategies Available
| Strategy | Description |
|---|---|
| Bands | Places orders at fixed price intervals around midpoint |
| AMM | Simulates AMM-like liquidity curve |
Configuration
# config.env
CONDITION_ID=0x... # Market identifier (hex)
STRATEGY=Bands # or "AMM"
CONFIG=./config/bands.json
7. Client Libraries
Official SDKs
| Language | Repository | Install |
|---|---|---|
| Python | py-clob-client | pip install py-clob-client |
| TypeScript | clob-client | npm i @polymarket/clob-client |
| Rust | rs-clob-client | Cargo crate |
Utilities
- python-order-utils - Generate and sign orders
- conditional-token-examples-py - CTF interaction examples
8. API Access
REST Endpoints
- Create, list, fetch orders
- Market price data
- Order book snapshots
WebSocket Endpoints
- Real-time market data
- Order history streaming
9. Risk Framework
Polymarket-Specific Risks
| Risk | Description | Mitigation |
|---|---|---|
| Binary volatility | All-or-nothing resolution zeros positions instantly | Position sizing (1-5% per market) |
| Capital lockup | Long-duration events tie up capital | Prefer shorter-term markets |
| Operator risk | Off-chain matching dependency | Operator is audited, limited privileges |
| Smart contract risk | Bug in CTFExchange | Chainsecurity audit completed |
| Resolution risk | Disputes over outcomes | Stick to clear, verifiable events |
Position Sizing
Cap any single market at 1-5% of bankroll, spread across uncorrelated events.
10. Polymarket Incentives
Liquidity Rewards Program
Polymarket pays market makers daily for providing liquidity:
| Factor | Impact on Rewards |
|---|---|
| Order proximity | Closer to midpoint = more rewards |
| Order size | Larger orders = more rewards |
| Competitive positioning | Better than others = more rewards |
Key Rules:
- Payout: Daily at ~midnight UTC
- Minimum threshold: $1 (below this, no payout)
- Max spread: Varies by market (e.g., 3¢ from midpoint)
- If midpoint < $0.10: Must quote both sides to qualify
Reported Earnings:
- Active makers report $200-$800/day during busy cycles
- Historical peak: $1 reward per $73 liquidity provided (Nov 2023 - Jan 2024)
- July total platform payout: $433,075
Strategy: Maximize LP Rewards
- Quote many markets simultaneously (use bots)
- Stay within max spread of each market
- Target markets with high rewards but low volatility
- Spread + LP rewards = combined yield
11. System Design: Strategy Framework
Strategy Taxonomy
We have four distinct strategies, each with different data requirements and risk profiles:
┌─────────────────────────────────────────────────────────────────┐
│ STRATEGY TAXONOMY │
├─────────────────────────────────────────────────────────────────┤
│ │
│ STRATEGY 1: Pure MM STRATEGY 2: Hedged MM │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ Polymarket Only │ │ Polymarket │ │
│ │ │ │ + │ │
│ │ Spread Capture │ │ Perps Hedge │ │
│ │ + LP Rewards │ │ │ │
│ └─────────────────┘ └─────────────────┘ │
│ Risk: Directional Risk: Basis, Funding │
│ Data: PM orderbook Data: PM + Perps price │
│ │
│ STRATEGY 3: Alpha MM STRATEGY 4: Arbitrage │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ Perps → Signal │ │ Perps vs PM │ │
│ │ ↓ │ │ Price Discrepancy│ │
│ │ Polymarket │ │ │ │
│ │ Informed Orders │ │ Directional Bet │ │
│ └─────────────────┘ └─────────────────┘ │
│ Risk: Signal decay Risk: Execution speed │
│ Data: Perps + PM + Vol Data: Both real-time │
│ │
└─────────────────────────────────────────────────────────────────┘
Strategy 1: Pure Market Making
Goal: Capture spread + LP rewards without hedging
Data Flow:
Polymarket WebSocket
│
▼
┌───────────────────┐
│ Order Book State │
│ - Best bid/ask │
│ - Midpoint │
│ - Spread │
└───────────────────┘
│
▼
┌───────────────────┐
│ Quote Generator │
│ bid = mid - δ │
│ ask = mid + δ │
└───────────────────┘
│
▼
Place Orders
Order Placement Logic:
# Simple symmetric quotes
mid_price = (best_bid + best_ask) / 2
half_spread = target_spread / 2
bid_price = mid_price - half_spread
ask_price = mid_price + half_spread
bid_size = base_order_size
ask_size = base_order_size
When to Use:
- Markets with low volatility
- Events far from resolution
- When you have no directional view
Risk: Full directional exposure to outcome
Strategy 2: Delta-Hedged Market Making
Goal: Capture spread + LP rewards while hedging directional risk
Data Flow:
┌──────────────────┐ ┌──────────────────┐
│ Polymarket WS │ │ Perps WS │
│ (Order Book) │ │ (BTC Price) │
└────────┬─────────┘ └────────┬─────────┘
│ │
▼ ▼
┌─────────────────────────────────────────────┐
│ FAIR VALUE ENGINE │
│ │
│ 1. Calculate binary delta for each position│
│ 2. Sum to get net delta │
│ 3. Determine perps hedge size │
└─────────────────────────────────────────────┘
│ │
▼ ▼
┌──────────────────┐ ┌──────────────────┐
│ Polymarket Orders│ │ Perps Hedge │
│ (MM quotes) │ │ (Delta offset) │
└──────────────────┘ └──────────────────┘
Order Placement Logic:
# 1. Calculate current delta exposure
total_delta = 0
for position in positions:
binary_delta = calc_binary_delta(
S=btc_price,
K=position.strike,
T=position.time_to_expiry,
sigma=implied_vol
)
total_delta += position.size * binary_delta
# 2. Determine hedge
target_perps_position = -total_delta * btc_price
# 3. Quote on Polymarket (inventory-adjusted)
inventory_skew = current_inventory / max_inventory
reservation_price = mid_price - (skew_factor * inventory_skew)
bid_price = reservation_price - half_spread
ask_price = reservation_price + half_spread
When to Use:
- Crypto price prediction markets
- When you want to isolate spread capture from directional risk
- Longer-duration markets (T > 2 weeks)
Risk: Basis divergence, funding rate flips, delta explosion near expiry
Strategy 3: Alpha-Informed Market Making
Goal: Use perps price movements to predict prediction market fair value
Core Insight:
Perps markets have deeper liquidity and faster price discovery. Prediction market prices LAG perps movements.
Data Flow:
┌────────────────────────────────────────────────────────────────┐
│ PERPS DATA FEED │
│ Binance/Bybit/Hyperliquid BTC-USDT Perpetual │
└────────────────────────────────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────────────┐
│ ALPHA SIGNAL ENGINE │
│ │
│ Inputs: │
│ - btc_price (real-time) │
│ - btc_price_1m_ago │
│ - btc_price_5m_ago │
│ - perps_funding_rate │
│ - perps_open_interest │
│ - order_book_imbalance │
│ │
│ Calculate: │
│ - momentum = (price - price_5m) / price_5m │
│ - fair_prob = black_scholes_binary(S, K, T, σ) │
│ - alpha = fair_prob - current_polymarket_price │
│ │
└────────────────────────────────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────────────┐
│ QUOTE ADJUSTMENT │
│ │
│ If alpha > threshold: │
│ - Skew quotes toward alpha direction │
│ - Widen spread on losing side │
│ - Tighten spread on winning side │
│ │
│ bid = fair_value - spread * (1 + alpha_adjustment) │
│ ask = fair_value + spread * (1 - alpha_adjustment) │
│ │
└────────────────────────────────────────────────────────────────┘
│
▼
Polymarket Orders
Fair Value Calculation:
def calculate_fair_value(btc_price, strike, time_to_expiry, vol):
"""
Binary option fair value using Black-Scholes
Returns probability that BTC > strike at expiry
"""
if time_to_expiry <= 0:
return 1.0 if btc_price > strike else 0.0
d2 = (np.log(btc_price / strike) +
(- 0.5 * vol**2) * time_to_expiry) / (vol * np.sqrt(time_to_expiry))
fair_prob = norm.cdf(d2) # N(d2) for binary call
return fair_prob
def calculate_alpha(fair_prob, market_price):
"""
Alpha = theoretical value - market price
Positive alpha = market underpriced, we should buy
"""
return fair_prob - market_price
Order Placement with Alpha:
# Calculate fair value from perps
fair_value = calculate_fair_value(btc_price, strike, T, vol)
alpha = fair_value - polymarket_mid
# Adjust quotes based on alpha
if abs(alpha) > alpha_threshold:
# Skew toward alpha direction
if alpha > 0: # Underpriced, we want to buy
bid_price = fair_value - tight_spread
ask_price = fair_value + wide_spread
else: # Overpriced, we want to sell
bid_price = fair_value - wide_spread
ask_price = fair_value + tight_spread
else:
# Symmetric quotes at fair value
bid_price = fair_value - base_spread
ask_price = fair_value + base_spread
When to Use:
- Fast-moving crypto markets
- When perps show clear momentum
- Markets with slow price discovery on Polymarket
Risk: Signal decay, model error, adverse selection if wrong
Strategy 4: Cross-Market Arbitrage
Goal: Exploit price discrepancies between perps-implied probability and Polymarket price
This is NOT market making - it's directional betting on mispricing
Data Flow:
┌─────────────────┐ ┌─────────────────┐
│ Perps Price │ │ Polymarket Price│
│ $98,500 │ │ YES @ $0.35 │
└────────┬────────┘ └────────┬────────┘
│ │
▼ ▼
┌─────────────────────────────────────────────┐
│ ARBITRAGE DETECTOR │
│ │
│ Strike: $100,000 │
│ Expiry: 7 days │
│ Vol: 60% │
│ │
│ Perps-implied prob: N(d2) = 0.42 (42%) │
│ Polymarket price: $0.35 (35%) │
│ │
│ Discrepancy: 7% → BUY YES │
│ │
└─────────────────────────────────────────────┘
│
▼
Buy YES tokens (directional bet)
Execution:
def detect_arbitrage(btc_price, strike, T, vol, pm_yes_price, pm_no_price):
fair_prob = calculate_fair_value(btc_price, strike, T, vol)
yes_edge = fair_prob - pm_yes_price
no_edge = (1 - fair_prob) - pm_no_price
if yes_edge > min_edge:
return ("BUY_YES", yes_edge)
elif no_edge > min_edge:
return ("BUY_NO", no_edge)
else:
return ("NO_TRADE", 0)
When to Use:
- Large sudden moves in BTC price
- When Polymarket is slow to reprice
- High-confidence mispricing (>5% edge)
Risk: Model could be wrong, execution slippage, market corrects against you
Data Feed Architecture
┌─────────────────────────────────────────────────────────────────┐
│ DATA FEED LAYER │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ Binance WS │ │ Polymarket WS │ │ Bybit WS │ │
│ │ BTC-USDT Perp │ │ Order Book │ │ BTC-USDT Perp │ │
│ │ ~50ms latency │ │ ~100ms latency│ │ ~50ms latency │ │
│ └───────┬───────┘ └───────┬───────┘ └───────┬───────┘ │
│ │ │ │ │
│ └──────────────────┼──────────────────┘ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ MARKET DATA PROVIDER │ │
│ │ │ │
│ │ - Normalizes data formats │ │
│ │ - Maintains order book state │ │
│ │ - Calculates derived metrics │ │
│ │ - Broadcasts to subscribers │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌──────────────────┼──────────────────┐ │
│ ▼ ▼ ▼ │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ Fair Value │ │ Alpha Signal │ │ Risk Manager │ │
│ │ Calculator │ │ Generator │ │ │ │
│ └───────────────┘ └───────────────┘ └───────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
Perps Data → Order Decision Flow
Step-by-step process:
EVERY 100ms:
1. RECEIVE perps price update
└─> btc_price = 98,500
2. CALCULATE fair value for each market
└─> Market "BTC > 100k by Jan 31"
└─> fair_prob = N(d2) = 0.42
3. COMPARE to Polymarket prices
└─> pm_yes = 0.38, pm_no = 0.62
└─> alpha = 0.42 - 0.38 = +0.04
4. CALCULATE inventory position
└─> current_yes = 1000, current_no = 500
└─> net_position = +500 (long YES)
└─> inventory_skew = 500 / 2000 = 0.25
5. DETERMINE quote prices
└─> reservation_price = fair_prob - (γ * inventory_skew)
└─> reservation_price = 0.42 - (0.1 * 0.25) = 0.395
└─> bid = 0.395 - 0.02 = 0.375
└─> ask = 0.395 + 0.02 = 0.415
6. ADJUST for alpha signal
└─> alpha > 0, so tighten bid, widen ask
└─> bid = 0.38 (tighter)
└─> ask = 0.42 (wider)
7. CHECK risk limits
└─> position < max_position? ✓
└─> delta within bounds? ✓
8. SEND orders to Polymarket
└─> Cancel stale orders
└─> Place new bid @ 0.38
└─> Place new ask @ 0.42
9. UPDATE perps hedge (every 30s)
└─> Calculate aggregate delta
└─> Adjust perps position
Configuration Parameters
CONFIG = {
# Market making parameters
"base_spread": 0.02, # 2 cents
"tight_spread": 0.01, # 1 cent (when alpha confirms)
"wide_spread": 0.03, # 3 cents (when alpha opposes)
"base_order_size": 100, # $100 per side
# Inventory management
"max_position": 2000, # Max $2000 in any direction
"inventory_skew_factor": 0.1, # How much to skew for inventory
"target_inventory": 0, # Target neutral
# Alpha thresholds
"alpha_threshold": 0.03, # 3% to act on alpha
"arb_threshold": 0.05, # 5% for pure arbitrage
# Risk limits
"max_delta_usd": 5000, # Max $5000 delta exposure
"max_loss_daily": 500, # Stop trading after $500 loss
# Timing
"quote_refresh_ms": 100, # Refresh quotes every 100ms
"hedge_refresh_s": 30, # Rebalance hedge every 30s
"min_time_to_expiry_days": 7, # Exit before this
# Volatility
"default_vol": 0.60, # 60% annualized
"vol_lookback_days": 30, # For realized vol calc
}
12. Edge Strategies
Crypto Markets: Perps Hedging Strategy (Deep Dive)
The Opportunity: Crypto prediction markets (e.g., "BTC > $100k by March") are essentially binary options. These can be hedged using perpetual futures, but the math is different from vanilla options.
Understanding Binary Option Delta
Prediction market tokens behave like digital/binary options:
| Property | Vanilla Option | Binary Option (Prediction Market) |
|---|---|---|
| Payoff | Continuous | Discontinuous ($0 or $1) |
| Delta shape | Smooth S-curve | Spike near strike at expiry |
| Gamma near expiry | High but finite | Approaches infinity at strike |
| Hedging | Standard delta hedge | Requires "over-hedging" with spreads |
Critical Insight:
"The delta of a binary call has the same shape as the gamma of a vanilla call"
This means binary option delta explodes near the strike as expiry approaches:
Binary Delta ≈ N'(d2) / (S × σ × √T)
Where:
- N'(d2) = standard normal PDF
- S = underlying price
- σ = volatility
- T = time to expiry
As T → 0 and S → Strike: Delta → ∞
Practical Implication: You CANNOT perfectly delta-hedge a binary option near expiry. The hedge ratio becomes unstable.
Strategy 1: Delta-Neutral Market Making (Far from Expiry)
When time to expiry is long (weeks/months), binary delta is manageable:
Example: "BTC > $120k by June 2026"
Current BTC: $95,000
YES price: $0.15 (15% implied probability)
Binary Delta ≈ 0.000002 per $1 BTC move (very small)
Hedge: Minimal perps position needed
The Math:
Binary Delta = e^(-rT) × N'(d2) / (S × σ × √T)
For BTC at $95k, strike $120k, 6 months out, 60% vol:
d2 = (ln(95000/120000) + (0 - 0.5×0.6²)×0.5) / (0.6×√0.5)
d2 ≈ -0.82
N'(d2) ≈ 0.29
Binary Delta ≈ 0.29 / (95000 × 0.6 × 0.71) ≈ 0.0000072
Per $1000 BTC move: YES price changes ~$0.0072 (0.72¢)
Strategy:
- Market make on Polymarket (capture spread + LP rewards)
- Calculate aggregate binary delta across all positions
- Hedge net delta with BTC perps
- Rebalance weekly (not continuously—too expensive)
Strategy 2: Funding Rate Arbitrage + Prediction Markets
Combine prediction market yields with perps funding income:
Setup:
Prediction Market: Long YES "BTC > $100k" @ $0.80
Perps: Short BTC perps (delta hedge)
Funding: Collect funding rate when positive
Expected Returns:
| Source | Estimated Yield |
|---|---|
| Polymarket LP rewards | $200-800/day |
| Bid-ask spread capture | 1-3% per trade |
| Perps funding (when positive) | 10-30% APR |
| Combined | 30-50%+ APR |
Historical Funding Rates:
- Basic static strategy: ~18% APR (Sharpe 1.4)
- Dynamic ML-predicted: ~31% APR (Sharpe 2.3)
- Peak scenarios: Up to 115% in 6 months
Strategy 3: Cross-Market Information Arbitrage
The Edge: Perps markets have deeper liquidity and faster price discovery than prediction markets.
Execution:
1. Monitor BTC perps price in real-time
2. When perps move sharply toward a strike level:
- Buy YES if approaching from below
- Buy NO if approaching from above
3. Prediction market prices lag by seconds to minutes
4. Exit when prediction market catches up
Example:
Strike: BTC > $100k
BTC perps spike from $99k to $100.5k in 30 seconds
Prediction market YES still priced at $0.45 (should be ~$0.70)
Action: Buy YES immediately
Exit: When YES reprices to $0.65-0.70
Profit: ~40% in minutes
Strategy 4: Call Spread Replication (Over-Hedging)
Banks hedge binary options using call spreads to smooth the delta:
Binary Call ≈ (1/ε) × [Call(K-ε) - Call(K)]
Where ε = "overhedge amount" (typically 3-8% of strike)
Applied to Prediction Markets:
Instead of: Long YES "BTC > $120k"
Replicate with:
- Long BTC Call @ $116k (K - 3%)
- Short BTC Call @ $120k (K)
- Notional = Prediction payout / $4k spread
This gives smoother delta and hedgeable gamma
Why This Matters:
- Traditional delta hedging of binaries can INCREASE risk
- "Over-hedging" with spreads costs more but is manageable
- Maximum delta = Payout / Overhedge amount
Risk Warnings
| Risk | Description | Mitigation |
|---|---|---|
| Basis risk | Perps and prediction markets can diverge | Size positions conservatively |
| Liquidation | Extreme moves can liquidate perps hedge | Use low leverage (2-3x max) |
| Funding flips | Funding can turn negative | Monitor and adjust |
| Delta explosion | Near expiry, hedging becomes impossible | Exit positions before expiry |
| Counterparty | Exchange risk (remember FTX) | Diversify across exchanges |
Key Rule:
Exit binary positions when T < 1 week unless you want pure directional exposure
Practical Implementation
Tools Needed:
- Polymarket account + py-clob-client
- Perps account (Binance, Bybit, Hyperliquid)
- Real-time price feeds for both
- Position tracker calculating aggregate delta
Monitoring Dashboard:
# Pseudo-code for delta tracking
for position in polymarket_positions:
binary_delta = calculate_binary_delta(
spot_price=btc_price,
strike=position.strike,
time_to_expiry=position.expiry - now,
volatility=implied_vol
)
total_delta += position.size * binary_delta
perps_hedge_size = -total_delta # Opposite sign
Emerging Infrastructure:
- Seda: Perpetual-style contracts using Polymarket data
- Limitless: 1-60 minute binary options on crypto
- Hyperliquid HIP-4: Event perpetuals trading probability changes
Sports Markets: AI/Computer Vision Edge
The Concept: Use computer vision to detect game events (goals, fouls, injuries) milliseconds before:
- Official data feeds update
- TV broadcast reaches viewers
- Polymarket prices adjust
Technical Requirements:
| Component | Specification |
|---|---|
| Video source | Direct stadium feed or low-latency stream |
| Latency target | <500ms end-to-end |
| Processing | Edge inference (GPU at venue or nearby) |
| Model | YOLO or similar (millisecond detection) |
The "Courtsiding" Precedent: Professional bettors already do this manually:
- Person at stadium relays events instantly
- Bets placed before official feeds update
- Exploits seconds of delay in TV/data broadcasts
Legal Note: Courtsiding is illegal in Australia (up to 10 years prison) but not explicitly banned in UK/US.
AI Advantages Over Manual Courtsiding:
- Faster than human reaction time
- Can track multiple events simultaneously
- No need for physical presence (if you have low-latency video)
- Scalable across multiple games
Challenges:
- Need ultra-low-latency video feed (Sportradar controls most official feeds)
- Polymarket may not have enough liquidity for rapid-fire betting
- Model must handle occlusions, camera angles, edge cases
Potential Architecture:
Stadium Camera → Edge GPU → CV Model → Event Detection
↓
Polymarket API → Place Order
Target: <500ms from event to order
12. Key Concepts to Study Further
- EIP-712 signature generation and verification
- Bands strategy parameter tuning
- WebSocket integration for real-time order management
- Inventory skew and mid-price adjustment
- Cross-market correlation mapping
13. Open Questions
- How to optimally set band widths as a function of time-to-resolution?
- What's the ideal sync cycle frequency for different market volatilities?
- How to detect and avoid toxic flow (informed traders)?
- Optimal inventory limits before hedging or stopping quoting?
Resources
Documentation
Code Repositories
- poly-market-maker - Official MM keeper
- ctf-exchange - Exchange contracts
- py-clob-client - Python SDK
Technical Deep Dives
Edge Strategy Resources
- Polymarket Liquidity Rewards
- Sportradar Live Data
- Computer Vision in Sports - Roboflow
- Real-Time Vision AI in Sports - GetStream
- Keyrock: Prediction Markets
Crypto Perps & Binary Options
- Digital Options Pricing & Hedging - Medium
- Delta Quants: Managing Digital Payoff Risks
- Delta Hedging Bitcoin Options - Taylor & Francis
- Funding Rate Arbitrage Guide - Amberdata
- Spot-Perp Arbitrage Explained - FXEmpire
- CME: Hedging Bitcoin with Options
Last updated: January 6, 2026