Build: Polymarket Prediction Market Strategy Engine - Reverse-Engineer & Backtest Canine-Commandment's $193K Profit Strategy

Objective

Reverse-engineer, document, and build a fully testable implementation of the trading strategy executed by Polymarket user "Canine-Commandment" (wallet: 0x1d0034134e339a309700ff2d34e99fa2d48b031).

This trader has achieved $193,784 in realized profit across 5,119 market trades with $22.05M in volume. Your job is to figure out HOW and make it reproducible.

Profile Reference

https://polymarket.com/@0x1d0034134e339a309700ff2d34e99fa2d48b031

CRITICAL: Must Run on a MacBook

The final deliverable MUST be executable on a standard MacBook (macOS 14+, Apple Silicon or Intel). Choose ONE of these delivery methods:

Option A: OpenClaw Skill (Preferred)

• Package as an OpenClaw skill that can be installed and run via openclaw install <skill-id> and openclaw run <skill-id>
• The skill should expose commands for: analyze (run full analysis), backtest (run backtester), paper-trade (live paper trading mode), report (generate report)
• Include a proper openclaw.yaml manifest

Option B: Standalone CLI Tool

• Single git clone + pip install -e . setup (or uv pip install)
• Must work with Python 3.10+ on macOS (no Linux-only deps, no Docker required)
• Include a Makefile or justfile with targets: make setup, make analyze, make backtest, make report
• All dependencies must be pure Python or have macOS wheels available (no C compilation required)
• Include a pyproject.toml with all deps pinned

Either way:

• Free-tier crypto data APIs are fine and encouraged (CoinGecko, DeFiLlama, Polymarket CLOB API, etc.)
• No paid API keys required - free tiers and public endpoints only
• Must run fully offline after initial data fetch (cache all data locally)
• Include a make test or pytest command that validates everything works
• First-run experience: clone, install, run one command, see results within 5 minutes

Requirements

Phase 1: Data Collection & Analysis

• Scrape or collect the complete trading history for this wallet address from Polymarket (use their public API, subgraph, or on-chain data from Polygon)
• Catalog every position: market, direction (YES/NO), entry price, exit price, size, timing, outcome
• Identify which markets they traded (politics, crypto, sports, world events, etc.)
• Map the timeline of trades to understand sequencing and capital allocation
• Cache all fetched data locally so analysis can run offline

Phase 2: Strategy Identification

• Classify the trading patterns: Are they primarily a market maker, momentum trader, contrarian, news-based, or arbitrageur?
• Identify entry signals: What price levels, market conditions, or timing patterns trigger entries?
• Identify exit signals: Do they take profit at specific thresholds? Do they hold to resolution?
• Analyze position sizing: How do they allocate across markets? What's their max position size relative to portfolio?
• Identify risk management: Stop losses, diversification rules, max exposure per market
• Calculate key metrics: win rate, average win size, average loss size, Sharpe ratio, max drawdown, profit factor
• Determine if the strategy is scalable or if it depends on being early/small

Phase 3: Testable Implementation

• Build a Python-based backtesting engine that can replay this strategy against historical Polymarket data
• The engine should:
  • Ingest historical market data (odds over time, resolution outcomes)
  • Simulate the identified strategy rules against that data
  • Output: total P&L, win rate, Sharpe ratio, max drawdown, trade log
  • Support parameter tuning (e.g., different entry/exit thresholds)
  • Include paper trading mode that can run against live Polymarket data
• Include a comparison mode that runs the strategy vs. simple baselines (random, always-YES, etc.)
• ALL of this must run locally on a MacBook - no cloud infrastructure required

Phase 4: Documentation & Deliverables

• Detailed written report (10+ pages) covering:
  • Executive summary of the strategy
  • Data analysis with charts/visualizations
  • Strategy rules in plain English
  • Backtesting results with performance metrics
  • Risk assessment and limitations
  • Recommendations for improvements
• Clean, documented Python codebase with:
  • README with setup instructions (must include macOS-specific steps)
  • pyproject.toml with all deps pinned
  • Unit tests for core strategy logic (pytest)
  • Example notebooks showing analysis (Jupyter)
• All raw data used in the analysis (cached locally)
• A screencast or step-by-step walkthrough showing it running on macOS

Technical Stack

• Python 3.10+ (must work on macOS with Apple Silicon)
• Data: Polymarket API, Polygon blockchain data (public RPCs), The Graph subgraph
• Crypto pricing data: Free-tier APIs are encouraged. Good options include:
  • CoinGecko free API (no key required for basic endpoints)
  • Polymarket's own CLOB API for market pricing
  • DeFiLlama API (free, no key)
  • Polygon public RPCs for on-chain data
  • Any other free crypto data API that doesn't require a paid subscription
• Libraries: pandas, numpy, matplotlib/plotly for viz, web3.py or httpx for data fetching
• Testing: pytest
• NO Docker, NO cloud services. Free-tier APIs with optional API keys are fine (must work without paid plans)
• Delivery: Public GitHub repo OR OpenClaw skill

Evaluation Criteria

• Runs on MacBook in under 5 minutes (clone to first results)
• Accuracy of strategy identification (does the backtest match actual performance?)
• Code quality and testability
• Depth of analysis
• Clarity of documentation
• Reproducibility (can someone else run it and get the same results?)

This is a high-value research and engineering job. We expect thorough, professional-grade work.