# Polymarket Dataset Description

Complete guide to the 5 parquet files in this dataset.

---

## 📁 File Overview

| File | Size | Description | Use Case |
|------|------|-------------|----------|
| `orderfilled.parquet` | 31GB | Raw blockchain events | Complete historical record |
| `trades.parquet` | 32GB | Processed trading data | Market analysis, price tracking |
| `markets.parquet` | 68MB | Market metadata | Market info, token mapping |
| `quant.parquet` | 21GB | Quantitative trading data | Trading algorithms, backtesting |
| `users.parquet` | 23GB | User behavior data | User analysis, wallet tracking |

---

## 1️⃣ orderfilled.parquet (31GB)

**Raw OrderFilled events from Polygon blockchain**

### Description
Original blockchain events decoded from two Polymarket exchange contracts:
- CTF Exchange: `0x4bfb41d5b3570defd03c39a9a4d8de6bd8b8982e`
- NegRisk CTF Exchange: `0xc5d563a36ae78145c45a50134d48a1215220f80a`

### Schema
```
timestamp           int64      # Unix timestamp
datetime            string     # Human-readable datetime
block_number        int64      # Blockchain block number
transaction_hash    string     # Transaction hash
log_index           int64      # Log index within transaction
contract            string     # Contract name
maker               string     # Maker address
taker               string     # Taker address
maker_asset_id      string     # Maker's asset ID (uint256 as string)
taker_asset_id      string     # Taker's asset ID (uint256 as string)
maker_amount_filled int64      # Maker's filled amount (wei)
taker_amount_filled int64      # Taker's filled amount (wei)
maker_fee           int64      # Maker fee (wei)
taker_fee           int64      # Taker fee (wei)
protocol_fee        int64      # Protocol fee (wei)
order_hash          string     # Order hash
```

### Key Features
- ✅ Complete blockchain data with no missing fields
- ✅ Includes block_number for time-series analysis
- ✅ Includes all fees (maker, taker, protocol)
- ✅ Contains order_hash for order tracking

### Use Cases
- Full historical blockchain analysis
- Fee analysis
- Order matching studies
- Raw event processing

---

## 2️⃣ trades.parquet (32GB)

**Processed trading data with market linkage**

### Description
Enhanced version of orderfilled events with:
- Market ID linkage (from token to market)
- Trade direction analysis (BUY/SELL)
- Price calculation
- USD amount extraction

### Schema
All fields from `orderfilled.parquet`, plus:
```
market_id           string     # Linked market ID
condition_id        string     # Condition ID
token_id            string     # Non-USDC token ID
answer              string     # Market outcome (YES/NO/etc.)
nonusdc_side        string     # Which side has token (token1/token2)
maker_direction     string     # Maker's direction (BUY/SELL)
taker_direction     string     # Taker's direction (BUY/SELL)
price               float64    # Trade price (0-1)
token_amount        int64      # Token amount (in wei)
usd_amount          int64      # USDC amount (in wei)
```

### Key Features
- ✅ Auto-linked to market metadata
- ✅ Trade direction calculated for both sides
- ✅ Price normalized to 0-1 range
- ✅ Preserves all original blockchain fields

### Use Cases
- Market price analysis
- Trading volume by market
- Direction-based analysis
- General trading analytics

---

## 3️⃣ markets.parquet (68MB)

**Market metadata from Gamma API**

### Description
Complete market information including:
- Market questions
- Outcome names
- Token IDs
- Resolution status

### Schema
```
market_id           string     # Unique market ID
question            string     # Market question
description         string     # Market description
outcomes            list       # List of outcome names
tokens              list       # List of token IDs
volume              float64    # Total trading volume
liquidity           float64    # Market liquidity
resolved            bool       # Is market resolved?
resolution          string     # Resolution outcome
created_at          timestamp  # Market creation time
end_date            timestamp  # Market end date
```

### Use Cases
- Market information lookup
- Token ID to market mapping
- Market category analysis

---

## 4️⃣ quant.parquet (21GB) - Quantitative Trading Data

**Cleaned trades with unified token perspective and direction**

### Description
Optimized version of `trades.parquet` for quantitative analysis with:
1. **Unified Token Perspective**: All trades normalized to YES token (token1)
2. **Unified Direction**: All trades converted to BUY perspective
3. **Contract Filtering**: Removed contract-to-contract trades

### Data Cleaning Process

#### Step 1: Filter Invalid Data
```python
# Remove trades with NaN prices
df = df[~df['price'].isna()]

# Remove contract addresses as taker (internal contract operations)
contract_addresses = {
    '0x4bfb41d5b3570defd03c39a9a4d8de6bd8b8982e',  # CTF Exchange
    '0xc5d563a36ae78145c45a50134d48a1215220f80a'   # NegRisk CTF Exchange
}
df = df[~df['taker'].str.lower().isin(contract_addresses)]
```

#### Step 2: Unified Token Perspective (YES/token1)
```python
# If trade involves token2 (NO token), flip the price
is_token2 = df['nonusdc_side'] == 'token2'
df.loc[is_token2, 'price'] = 1 - df.loc[is_token2, 'price']
df['nonusdc_side'] = 'token1'  # All normalized to token1/YES

# Example:
# Original: token2, price=0.3 → Normalized: token1, price=0.7
```

**Why?** In prediction markets:
- token1 = YES outcome (probability)
- token2 = NO outcome (1 - probability)

By normalizing all trades to YES perspective:
- price = 0.7 means 70% probability of YES
- Easier to compare across all trades
- Consistent time-series analysis

#### Step 3: Keep All Original Fields
Unlike `users.parquet`, `quant.parquet` preserves:
- Both maker and taker addresses
- Both maker_direction and taker_direction
- All blockchain metadata

### Schema
Same as `trades.parquet`, but with:
```
nonusdc_side        string     # Always 'token1' (unified)
price               float64    # YES token price (unified)
```

### Key Features
- ✅ Unified YES token perspective for all trades
- ✅ Contract trades filtered out
- ✅ Maintains maker/taker structure
- ✅ Preserves all original fields
- ✅ Clean data for backtesting

### Use Cases
- **Algorithmic Trading**: Consistent price signals
- **Backtesting**: Unified direction simplifies strategy testing
- **Price Prediction**: Model YES probability trends
- **Market Making**: Analyze bid-ask spreads
- **Volume Analysis**: Track real trading activity (no contracts)

---

## 5️⃣ users.parquet (23GB) - User Behavior Data

**User-centric view with split maker/taker records**

### Description
Transformed view of trades optimized for user behavior analysis:
1. **Split Records**: Each trade becomes 2 records (maker + taker)
2. **Unified Token Perspective**: All normalized to YES token
3. **Unified Direction**: All trades converted to BUY, negative amounts for sells
4. **Sorted by User**: Easy to analyze individual user trajectories

### Data Cleaning Process

#### Step 1: Filter Invalid Data (Same as quant)
```python
# Remove NaN prices and contract trades
df = df[~df['price'].isna()]
df = df[~df['taker'].str.lower().isin(contract_addresses)]
```

#### Step 2: Split Maker and Taker into Separate Records
```python
# Common fields for both sides
common = ['timestamp', 'datetime', 'block_number', 'transaction_hash',
          'market_id', 'price', 'token_amount', 'usd_amount']

# Maker record
maker_df = df[common + ['maker', 'maker_direction']].copy()
maker_df = maker_df.rename(columns={'maker': 'user', 'maker_direction': 'direction'})
maker_df['role'] = 'maker'

# Taker record
taker_df = df[common + ['taker', 'taker_direction']].copy()
taker_df = taker_df.rename(columns={'taker': 'user', 'taker_direction': 'direction'})
taker_df['role'] = 'taker'

# Concatenate
result = pd.concat([maker_df, taker_df])

# Original 1 trade → 2 records (expansion ratio ~2x)
```

#### Step 3: Unified Token Perspective (YES/token1)
```python
# If token2 trade, flip price (same as quant)
is_token2 = result['nonusdc_side'] == 'token2'
result.loc[is_token2, 'price'] = 1 - result.loc[is_token2, 'price']
```

#### Step 4: Unified Direction to BUY
```python
# Convert all SELL to BUY with negative token_amount
is_sell = result['direction'] == 'SELL'
result.loc[is_sell, 'token_amount'] = -result.loc[is_sell, 'token_amount']
result['direction'] = 'BUY'  # All records are now 'BUY'

# Example:
# Original SELL: direction='SELL', token_amount=100
# Unified BUY:  direction='BUY',  token_amount=-100
```

**Why?**
- **BUY** (token_amount > 0): User bought YES tokens, spent USDC
- **SELL** (token_amount < 0): User sold YES tokens, received USDC
- Single direction simplifies aggregation: `sum(token_amount)` = net position

#### Step 5: Sort by User and Time
```python
result = result.sort_values(['user', 'timestamp'])
```

### Schema
```
timestamp           int64      # Unix timestamp
datetime            string     # Human-readable datetime
block_number        int64      # Block number
transaction_hash    string     # Transaction hash
event_id            string     # Unique event identifier
market_id           string     # Market ID
condition_id        string     # Condition ID
user                string     # User address (was maker/taker)
role                string     # 'maker' or 'taker'
price               float64    # YES token price (unified)
token_amount        int64      # Token amount (negative if originally SELL)
usd_amount          int64      # USDC amount (wei)
```

### Key Features
- ✅ Each user appears in their own records
- ✅ Easy to track user trading history
- ✅ Unified BUY direction with signed amounts
- ✅ Sorted by user → timestamp for sequential analysis
- ✅ 2x expansion ratio (1 trade → 2 records)

### Use Cases
- **User Profiling**: Track individual user strategies
- **Wallet Analysis**: PnL calculation per user
- **Cohort Analysis**: User behavior segmentation
- **Position Tracking**: Sum token_amount = net position
- **Trading Pattern Detection**: Identify market makers, arbitrageurs
- **User Journey**: Sequential trade analysis

### Example: Calculate User Net Position
```python
import pandas as pd

users = pd.read_parquet('users.parquet')

# Net position per user per market
position = users.groupby(['user', 'market_id'])['token_amount'].sum()

# User with long position (bought more than sold)
positive_position = position[position > 0]

# User with short position (sold more than bought)
negative_position = position[position < 0]
```

---

## 🔄 Data Processing Pipeline

```
Polygon Blockchain
       ↓
   RPC Query (OrderFilled events)
       ↓
   Decode ABI
       ↓
orderfilled.parquet (31GB)
   ├─→ Link market_id via Gamma API
   ↓
trades.parquet (32GB)
   ├─→ Filter + Unified YES perspective
   ├─→ Keep maker/taker structure
   ↓
quant.parquet (21GB)
   │
   └─→ Split maker/taker + Unified BUY direction
       ↓
   users.parquet (23GB)
```

---

## 🆚 Comparison: quant vs users

| Feature | quant.parquet | users.parquet |
|---------|---------------|---------------|
| **Perspective** | Trade-centric | User-centric |
| **Records per trade** | 1 | 2 (maker + taker) |
| **Size** | 21GB | 23GB |
| **Token normalization** | ✅ YES (token1) | ✅ YES (token1) |
| **Direction** | Preserved (BUY/SELL) | Unified (BUY only) |
| **Maker/Taker** | Both preserved | Split into rows |
| **Sort order** | Original | User → Time |
| **Use case** | Trading algorithms | User behavior |

---

## 💡 Usage Examples

### Example 1: Load Quant Data for Backtesting
```python
import pandas as pd

quant = pd.read_parquet('quant.parquet')

# All trades in YES token perspective
# Price represents YES probability
market_data = quant[quant['market_id'] == 'specific_market']

# Calculate returns
market_data = market_data.sort_values('timestamp')
market_data['returns'] = market_data['price'].pct_change()
```

### Example 2: Analyze User Trading Patterns
```python
users = pd.read_parquet('users.parquet')

# Get one user's trading history
user_trades = users[users['user'] == '0x123...']

# Calculate net position (positive = long, negative = short)
net_position = user_trades.groupby('market_id')['token_amount'].sum()

# Identify strategy
if (user_trades['role'] == 'maker').mean() > 0.7:
    strategy = 'Market Maker'
elif net_position.abs().mean() < 1000:
    strategy = 'Scalper'
else:
    strategy = 'Position Trader'
```

---

## 📊 Data Quality

### Completeness
- ✅ All OrderFilled events since contract deployment
- ✅ No missing blocks (failed fetches are retried)
- ✅ All blockchain fields preserved

### Cleaning Rules
- ❌ Removed: Contract-to-contract trades
- ❌ Removed: Trades with NaN prices
- ✅ Kept: All user-to-user trades
- ✅ Kept: All fee information

### Token Normalization
- All `quant.parquet` and `users.parquet` prices represent **YES token probability**
- Original token2 prices are flipped: `price_yes = 1 - price_no`
- Consistent for time-series and cross-market analysis

---

## 🔗 Relationships

```
markets.parquet
    ↓ (market_id)
trades.parquet
    ↓ (filter + normalize)
quant.parquet (trade-level)
users.parquet (user-level)
```

---

## ⚖️ License

MIT License - Free for commercial and research use

---

## 📞 Questions?

- GitHub Issues: [polymarket-data](https://github.com/SII-WANGZJ/polymarket-data/issues)
- Dataset: [HuggingFace](https://huggingface.co/datasets/SII-WANGZJ/Polymarket_data)