Polymarket FastLoop Trader , Improved

intent

this skill trades Polymarket's 5-minute and 15-minute fast markets on BTC, ETH, and SOL by detecting CEX momentum divergence from the 50-cent midpoint, confirmed via funding rate and order book signals. use it when you want to scalp sprint markets with rigorous edge filtering, fee-accurate profit math, and real win-rate tracking. default runs paper mode to validate calibration before live trading.

inputs

environment variables:

• SIMMER_API_KEY (required): Simmer SDK authentication key. get this from your Simmer account dashboard. stored in .env or shell export.

external connections:

• binance rest API (public endpoints): fetch 1-minute candles, perpetual funding rates, order book level 2 data. no auth needed; rate limit is 1200 req/min. this skill respects backoff headers.
• polymarket CLOB API (REST): list active fast markets by expiry window, fetch mid-price, submit/cancel orders. no auth needed for reads; order placement requires Polymarket wallet connected via Simmer SDK.
• polymarket outcome API: after market expiry, fetch final outcomes to resolve paper trades. public endpoint.

local files:

• fastloop_ledger.json: persistent trade log. created on first run. contains entry price, signals fired, outcome, P&L, timestamp, and win-rate stats by asset/threshold/hour.
• fastloop_config.json (optional): stores user-set overrides. skill uses defaults if missing.

runtime dependencies:

• Python 3.9+
• simmer-sdk (installed via pip)
• requests, pandas (standard data handling)

procedure

1. initialization: load config from fastloop_config.json or apply defaults. check SIMMER_API_KEY is set; fail with clear message if not. initialize empty trade ledger if missing. log session start with timestamp and mode (paper vs. live).

2. fetch CEX data: call binance REST API for last N 1-minute candles (N = lookback_minutes). extract open and close prices. compute momentum = (close_now - open_then) / open_then * 100. log raw candle data for audit.

3. evaluate momentum signal: if momentum >= min_momentum_pct, momentum signal fires. if momentum < min_momentum_pct, skip all downstream logic and loop back to step 2 after 5 seconds. output: momentum_pct, signal_fired (bool).

4. time-of-day filter: if time_filter=true and current UTC hour is in [02, 03, 04, 05] (02:00-06:00 UTC), log "low liquidity window, skipping" and loop back to step 2. if time_filter=false, proceed. output: hour_utc, filter_passed (bool).

5. optional: funding rate confirmation: if require_funding=true, fetch Binance perpetual funding rate for asset. if momentum is upward and funding > 0, log "crowded longs, signal degraded" and skip to step 2. if momentum is upward and funding <= 0, log "funding confirms upside" and proceed. invert logic for downward momentum. output: funding_rate, confirmation (bool).

6. optional: order book confirmation: if require_orderbook=true, fetch Binance L2 book top 20 bids/asks. compute imbalance = (bid_depth - ask_depth) / (bid_depth + ask_depth). if momentum is upward and imbalance >= 0.1, log "book confirms upside" and proceed. if momentum is upward and imbalance < 0.1, log "book neutral or inverted, skipping". invert for downward momentum. output: imbalance, confirmation (bool).

7. list polymarket fast markets: query Polymarket CLOB API for 5-minute and 15-minute markets on the chosen asset (BTC, ETH, or SOL). filter by time remaining: exclude if less than min_time_remaining seconds. rank by preference: pick market closest to target_time_min to target_time_max window. output: market_id, seconds_to_expiry, mid_price.

8. fee breakeven calculation: given mid_price and momentum direction (long or short), compute entry_price as mid_price plus/minus entry_threshold. for long: win_profit = (1 - entry_price) * (1 - 0.10). breakeven = entry_price / (win_profit + entry_price). required_divergence = (breakeven - 0.50) + fee_buffer. actual_divergence = abs(entry_price - 0.50). if actual_divergence < required_divergence, log "insufficient edge, skipping" and loop to step 2. output: entry_price, required_div, actual_div, edge_ok (bool).

9. volatility-adjusted sizing: fetch last 24 hours of hourly close prices for the asset from Binance. compute realized vol = std(hourly % returns) * sqrt(24). size = max_position * min(1.0, 0.02 / vol). if size <= 0.01 (too small), log "volatility too high, skip" and loop to step 2. output: vol_24h, position_size_usd.

10. daily budget check: sum all fills (live or paper) from last 24 UTC hours in ledger. if cumulative >= daily_budget, log "daily budget exhausted" and loop to step 2. otherwise proceed. output: cumulative_spend_24h, budget_remaining.

11. submit order: build order on Polymarket. side = YES if momentum is upward, NO if downward. amount = position_size_usd. price = entry_price. order_type = limit. if paper mode, simulate fill immediately at limit price (assume liquidity exists). if live mode, submit via Polymarket CLOB and wait up to 10 seconds for fill. if no fill after 10 seconds, cancel and log "no fill, timeout" and loop to step 2. output: order_id, fill_price, fill_time_utc, trade_status.

12. ledger entry: append trade to fastloop_ledger.json with fields: timestamp, mode (paper/live), asset, window (5m/15m), market_id, side (YES/NO), entry_price, position_size, all signals (momentum_pct, funding_rate, imbalance), fee_buffer used, outcome (null initially), pnl (null initially). output: ledger_written (bool).

13. loop back: wait 5 seconds. go to step 2. if running in --quiet mode, suppress all logs except errors and final summary. if running as cron job, exit cleanly after one loop.

decision points

if momentum < min_momentum_pct: skip all downstream checks, loop to step 2 after 5 seconds.

if time_filter=true and current UTC hour in [02,03,04,05]: skip trade, loop to step 2.

if require_funding=true and funding rate contradicts momentum: skip trade, loop to step 2. else if require_funding=false, skip funding check and proceed to order book.

if require_orderbook=true and order book imbalance does not confirm momentum (threshold +/- 0.1): skip trade, loop to step 2. else if require_orderbook=false, skip order book check and proceed to fee math.

if actual_divergence < required_divergence (fee math fails): skip trade, log reason, loop to step 2.

if vol is too high (size would be < $0.01): skip trade, loop to step 2.

if daily spend >= daily_budget: skip trade, loop to step 2.

if live mode and no fill within 10 seconds: cancel order, log "no fill", loop to step 2.

if paper mode: simulate fill immediately at limit price and record in ledger.

on --resolve flag: scan ledger for expired markets (timestamp + market expiry >= now). fetch outcome from Polymarket API. update ledger with outcome and compute PnL. update win_rate_pct = (wins / total_trades) * 100.

on --stats flag: read ledger, group by asset / momentum_threshold / hour_utc. display win rate, avg PnL, sample size, and recommendation (e.g. "raise threshold to 1.5%") for each group.

output contract

console output (live and paper):

• each loop iteration prints: timestamp, asset, momentum_pct, all signals evaluated (funding, orderbook, time filter), final decision (trade / skip), and reason if skipped.
• on trade: order_id, side (YES/NO), entry_price, position_size_usd, expected_outcome (win if momentum hits).

fastloop_ledger.json format:

[
  {
    "timestamp": "2025-01-15T14:23:45Z",
    "mode": "paper",
    "asset": "BTC",
    "window": "5m",
    "market_id": "0x1234...",
    "seconds_to_expiry": 120,
    "side": "YES",
    "entry_price": 0.52,
    "position_size_usd": 4.85,
    "momentum_pct": 1.2,
    "funding_rate": 0.0015,
    "funding_required": false,
    "funding_passed": null,
    "orderbook_imbalance": 0.08,
    "orderbook_required": false,
    "orderbook_passed": null,
    "time_filter_passed": true,
    "fee_buffer": 0.05,
    "breakeven_div": 0.068,
    "actual_div": 0.02,
    "edge_passed": true,
    "vol_24h_pct": 2.1,
    "order_id": "order_789",
    "fill_price": 0.52,