Weather High-Temp Sniper

intent

This skill runs an automated trading bot for Polymarket weather markets focused on "highest temperature" predictions. it discovers new markets every 6 hours using Simmer's /markets/importable endpoint, then executes buy orders on YES shares during a specific 9-10 AM local time window when the probability price exceeds a configurable threshold. use this when you want hands-off arbitrage on weather prediction markets with timezone-aware entry logic and optional Telegram alerts.

inputs

Required

• SIMMER_API_KEY (environment variable): your Simmer API key from simmer.markets/dashboard. no default; skill will not run without it.
• Python 3.8+
• Polymarket linked wallet: bot auto-links on first run if credentials available

Optional

• TELEGRAM_BOT_TOKEN (environment variable): telegram bot token in format 123456:ABC-DEF.... required only if telegram notifications are enabled.
• TELEGRAM_CHAT_ID (environment variable): your numeric telegram user ID (not username). required only if telegram notifications are enabled.
• SIMMER_SNIPER2_ENTRY_PRICE_THRESHOLD (environment variable): minimum YES probability to buy. default 0.35 (35%).
• SIMMER_SNIPER2_MAX_POSITION_USD (environment variable): max USD per trade. default 2.50.
• SIMMER_SNIPER2_SHARES (environment variable): shares per order. default 5 (polymarket minimum).
• SIMMER_SNIPER2_SLIPPAGE (environment variable): max slippage tolerance. default 0.15 (15%).
• SIMMER_SNIPER2_SCAN_INTERVAL (environment variable): seconds between opportunity scans. default 300 (5 minutes).
• SIMMER_SNIPER2_FALLBACK_10AM (environment variable): enable 10:00-10:05 AM fallback window. default true.
• SIMMER_SNIPER2_TELEGRAM_ENABLED (environment variable): enable telegram alerts. default false.
• SIMMER_SNIPER2_REPORT_INTERVAL (environment variable): seconds between periodic reports. default 240 (4 minutes).

External Dependencies

• Simmer SDK: market discovery via list_importable_markets(), check_market_exists(), import_market(), get_markets(), place_order().
• Polymarket: order execution and wallet management.
• Telegram API (optional): real-time trade and error notifications.

procedure

Phase 1: Market Discovery (runs every 6 hours)

1. Query daily import quota from Simmer API.

   • Input: api key, venue="polymarket"
   • Output: remaining quota count

2. Call list_importable_markets(venue="polymarket", q="highest temperature").

   • Input: query string, api key
   • Output: list of candidate market objects from polymarket

3. For each candidate market, filter using weather heuristics: must contain ("temperature" OR "temp" OR "°c" OR "°f") AND ("highest" OR "high"), and must NOT contain ("lowest" OR "minimum" OR "low" OR "below" OR "fall below" OR "crypto" OR "bitcoin" OR "election" OR "president" OR "sports" OR noise keywords).

   • Input: raw market list
   • Output: filtered candidate list

4. For each filtered candidate, call check_market_exists(market_id) to avoid duplicate imports.

   • Input: candidate market id
   • Output: boolean (exists or not)

5. If market does not exist and quota remains, call import_market(market_id).

   • Input: market id, api key
   • Output: success confirmation or error

6. Repeat steps 4-5 until quota exhausted or no more candidates.

   • Input: remaining quota, candidate list
   • Output: import count, timestamp logged to sniper.state.json as last_discovery_ts

Phase 2: Active Market Scanning (runs every scan_interval_seconds, default 5 minutes)

1. Call get_markets(import_source="polymarket", status="active", max_hours_to_resolution=48).

   • Input: api key, filters
   • Output: list of active polymarket markets

2. Locally filter markets using same weather heuristics as phase 1.

   • Input: active market list
   • Output: filtered weather market list

3. For each weather market, extract city name from question string.

   • Input: market question text
   • Output: city string (e.g., "New York", "London")

4. Look up timezone from CITY_TZ_MAP (hardcoded mapping of major cities to IANA tznames).

   • Input: city string
   • Output: tzname (e.g., "America/New_York") or None if city not recognized

5. Get current local time in that timezone. check if local hour is 9 (9:00-9:59 AM).

   • Input: tzname, current UTC time
   • Output: boolean (in 9-10 AM window or not)

6. If in window, read current_probability from market object (expressed 0.0-1.0).

   • Input: market object
   • Output: yes price (float)

7. Compare yes price to entry_price_threshold. if yes_price >= threshold, proceed. else skip market.

   • Input: yes_price, threshold
   • Output: boolean (passes threshold)

8. Check sniper.state.json for traded_today list. if market_id already in list, skip. else proceed.

   • Input: market_id, state file
   • Output: boolean (not yet traded today)

9. Calculate cost: shares_per_order × yes_price.

   • Input: shares (default 5), yes_price
   • Output: cost (float)

10. Compare cost to max_position_usd. if cost <= max_position_usd, proceed. else skip.

    • Input: cost, max_position_usd
    • Output: boolean (within position limit)

11. Call place_order(market_id=market_id, side="buy", shares=shares_per_order, price=yes_price, slippage=slippage_tolerance).

    • Input: market_id, side, shares, price, slippage, api key
    • Output: order_id or error

12. If order succeeds, append market_id to sniper.state.json["traded_today"]. log timestamp.

    • Input: order_id, market_id, current timestamp
    • Output: updated state file

13. If telegram enabled, send trade notification with market details, price, shares, cost.

    • Input: order_id, market_id, yes_price, shares, cost, telegram token, chat_id
    • Output: telegram message sent or error logged

14. If any error occurs (network timeout, api rate limit, invalid order), log error and send telegram alert if enabled.

    • Input: error object
    • Output: log entry, telegram message (optional)

Phase 3: Periodic Reporting (runs every report_interval_seconds, default 4 minutes)

1. Check timestamp of last report in sniper.state.json["last_report_ts"].

   • Input: state file
   • Output: last_report_ts (unix timestamp)

2. If current_time - last_report_ts > report_interval, send summary.

   • Input: current_time, last_report_ts
   • Output: boolean (time to report)

3. Compose report: total trades today (length of traded_today), current positions (call get_positions()), pnl summary, next discovery window.

   • Input: state file, positions api response
   • Output: report string

4. Send via telegram if enabled, else print to stdout.

   • Input: report string, telegram config
   • Output: telegram message or console output

5. Update sniper.state.json["last_report_ts"] to current time.

   • Input: current_time
   • Output: updated state file

Phase 4: Shutdown & Cleanup

1. On Ctrl+C or termination signal, gracefully close connections.

   • Input: signal
   • Output: none

2. Send "bot offline" telegram message if enabled.

   • Input: telegram config
   • Output: telegram message

3. Exit process.

   • Input: none
   • Output: process exits

decision points

Discovery Window (if/else)

• if current_time is midnight UTC OR 6 hours since last discovery: run discovery phase.
• else: skip discovery, proceed to scanning.

Market Filtering (if/else)

• if market question contains weather keywords AND does NOT contain noise keywords: include in candidates.
• else: skip market.

Timezone Lookup (if/else)

• if city name found in CITY_TZ_MAP: use detected timezone.
• else if city not recognized: skip market (insufficient data to determine local time).

Time Window (if/else)

• if local hour is 9 (9:00-9:59 AM in market's timezone): check entry conditions.
• else if fallback enabled AND local hour is 10 AND local minute < 5 (10:00-10:05 AM): check entry conditions.
• else: skip market, wait for next scan.

Price Threshold (if/else)

• if yes_price >= entry_price_threshold: proceed to position checks.
• else: skip market, price too low.

Trade History (if/else)

• if market_id NOT in sniper.state.json["traded_today"]: proceed to position size check.
• else if market_id in traded_today: skip market, already traded today. reset list at midnight UTC.

Position Size (if/else)

• if (shares_per_order × yes_price) <= max_position_usd: execute buy order.
• else: skip market, position would exceed max exposure.

Order Execution (if/else)

• if place_order() returns success (order_id): record trade in state, send telegram alert, continue.
• else if error is network timeout OR rate limit: log error, retry on next scan interval.
• else if error is invalid order (e.g., market closed, bad price): log error, send telegram alert, skip market.

Telegram (if/else)

• if telegram_enabled is true AND telegram_bot_token is set: send all alerts and reports.
• else: only log to stdout/stderr.

Import Quota (if/else)

• if remaining_quota > 0: attempt to import candidate market.
• else: log "quota exhausted", skip remaining candidates, wait until next UTC day.

output contract

State File: sniper.state.json Located in skill root directory. format:

{
  "date": "2025-01-15",
  "traded_today": ["market_id_1", "market_id_2"],
  "last_report_ts": 1705312345,
  "last_discovery_ts": 1705312000
}

• date: ISO date string (YYYY-MM-DD). reset to current UTC date daily.
• traded_today: list of market_ids already traded today (empty list if no trades yet).
• last_report_ts: unix timestamp of last periodic report sent.
• last_discovery_ts: unix timestamp of last market discovery phase.

Telegram Notifications (if enabled)

• Trade alert: "BOUGHT 5 YES on POLYMARKET:highest-temp-london-jan15 @ 0.38 cost=$1.90"
• Error alert: "ERROR: market polymarket:xyz closed, skipped"
• Daily report: "TRADES: 3, POSITIONS: 2 active, PNL: +$2.15"
• Shutdown message: "sniper offline"

Logs

• stdout/stderr: trade confirmations, skipped markets with reasons, errors, periodic reports.
• no file logging by default (can be added via config).

Polymarket Orders

• orders placed via place_order() execute immediately if price available and wallet funded.
• order_id returned and logged.

outcome signal

success is confirmed by any of these signals:

1. Trade Executed: order_id returned from place_order(), market_id appended to traded_today in state file, stdout logs "BOUGHT X YES on MARKET_ID @ PRICE cost=$Y.ZZ".

2. Telegram Trade Alert: if telegram enabled, user receives notification within 10 seconds of order execution.

3. Periodic Report Received: if telegram enabled, user receives summary report every 4 minutes (configurable). if stdout only, report printed to console.

4. State File Updated: sniper.state.json reflects latest traded_today list and timestamps, persists across restarts.

5. No Errors in Logs: if skill runs for 6+ hours without "ERROR" or "EXCEPTION" messages, it's operating normally. network timeouts logged as "WARN", not "ERROR".

6. Dry Run Matches Live: run with python sniper.py (dry run) and verify markets/prices printed match those traded in --live mode, confirming logic is deterministic.

failure signals:

• SIMMER_API_KEY not set: skill exits immediately, logs error.
• Telegram: bot token invalid: skill logs "WARN: telegram unavailable", continues without alerts.
• No markets found: skill logs "INFO: no weather markets matched criteria", continues scanning every 5 min.
• Quota exhausted: skill logs "INFO: import quota exhausted (0/10)", skips discovery until next UTC day.
• Wallet not linked: skill logs "ERROR: polymarket wallet not linked", attempts auto-link on first run, exits if fails.
• Network timeout on order: logged as "WARN: order timeout, retrying next scan", does not block future scans.