Chào mừng bạn quay lại blog kỹ thuật của HolySheep AI. Hôm nay tôi sẽ chia sẻ một bài viết chuyên sâu về việc khai thác dữ liệu lịch sử của Deribit BTC Options thông qua API — một chủ đề mà tôi đã dành hơn 6 tháng nghiên cứu và thực chiến trong các dự án quantitative trading của mình.

Trong bài viết này, bạn sẽ học được cách lấy dữ liệu quyen chọn BTC, tính toán implied volatility, backtest chiến lược, và quan trọng nhất — tôi sẽ so sánh chi tiết giữa các data provider để bạn có thể đưa ra quyết định sáng suốt nhất cho ngân sách và nhu cầu của mình.

Bảng So Sánh Tổng Quan: HolySheep vs Deribit API vs Tardis

Tiêu chí HolySheep AI Deribit API (chính thức) Tardis Machine Cryptofeed
Phí hàng tháng $0 - $49 (Free tier) Miễn phí (rate limited) $99 - $499/tháng Miễn phí (self-hosted)
Data retention 2 năm Real-time only 5+ năm Tùy server
Độ trễ API <50ms 100-300ms 200-500ms 50-200ms
Implied Volatility ✅ Tính sẵn ❌ Raw data only ✅ Tính sẵn ❌ Cần tự tính
Webhook/WebSocket ✅ ✅ ✅ ✅
Hỗ trợ tiếng Việt ✅ WeChat/Alipay ❌ ❌ ❌
Free credits $5 khi đăng ký 0 14 ngày trial 0

Giới Thiệu Về Deribit Options Data

Deribit là sàn giao dịch quyền chọn BTC và ETH lớn nhất thế giới tính theo open interest. Với hơn $10 tỷ Open Interest đỉnh cao và khối lượng giao dịch hàng ngày vượt $500 triệu, Deribit là nguồn dữ liệu không thể thiếu cho bất kỳ ai muốn nghiên cứu thị trường options.

Tuy nhiên, việc lấy dữ liệu lịch sử từ Deribit API chính thức gặp nhiều hạn chế nghiêm trọng. Trong thực chiến, tôi đã từng mất 3 ngày chỉ để debug một vấn đề về WebSocket reconnection — và đó là khi tôi nghĩ mình đã hiểu rõ API documentation.

Kiến Trúc Data Pipeline Cho Deribit Options

Trước khi đi vào code, hãy hiểu rõ kiến trúc tổng thể của một hệ thống thu thập dữ liệu Deribit options hiệu quả:

┌─────────────────────────────────────────────────────────────────────┐
│                    DERIBIT OPTIONS DATA ARCHITECTURE                │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐          │
│  │  Deribit     │    │   Tardis     │    │   HolySheep  │          │
│  │  WebSocket   │    │   API        │    │   AI         │          │
│  │  (Direct)    │    │   (Proxied)  │    │   (Analytics)│          │
│  └──────┬───────┘    └──────┬───────┘    └──────┬───────┘          │
│         │                   │                   │                   │
│         ▼                   ▼                   ▼                   │
│  ┌─────────────────────────────────────────────────────────┐       │
│  │                  DATA NORMALIZATION LAYER                │       │
│  │  - Option Chain Aggregation                              │       │
│  │  - IV Calculation (Black-Scholes)                        │       │
│  │  - Greeks Computation (Delta, Gamma, Vega, Theta)        │       │
│  └─────────────────────────────────────────────────────────┘       │
│                              │                                     │
│                              ▼                                     │
│  ┌─────────────────────────────────────────────────────────┐       │
│  │                  STORAGE & ANALYSIS                      │       │
│  │  - Time-series Database (InfluxDB/TimescaleDB)           │       │
│  │  - ML Pipeline (Backtest Engine)                         │       │
│  │  - HolySheep AI for Natural Language Queries             │       │
│  └─────────────────────────────────────────────────────────┘       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Setup Môi Trường và Cài Đặt Dependencies

# Python 3.10+ required

Install dependencies

pip install deribit-websocket-api pandas numpy scipy
pip install asyncio websockets aiohttp
pip install holy-sheap-sdk  # HolySheep AI SDK


Alternative: Docker setup for production

docker run -d \
  --name deribit-collector \
  -p 8080:8080 \
  -e DERIBIT_KEY=your_api_key \
  -e HOLYSHEEP_KEY=YOUR_HOLYSHEEP_API_KEY \
  holy sheep/deribit-collector:latest

Code 1: Kết Nối Deribit WebSocket và Lấy Dữ Liệu Options Chain

"""
Deribit BTC Options Real-time Data Collector
Author: HolySheep AI Technical Team
Version: 2.1.1837
"""

import asyncio
import json
import hmac
import hashlib
import time
from datetime import datetime
from typing import Dict, List, Optional
import pandas as pd
import numpy as np

class DeribitOptionsCollector:
    """
    Production-grade Deribit Options Data Collector
    Supports: BTC, ETH options chain, implied volatility calculation
    """
    
    WS_URL = "wss://www.deribit.com/ws/api/v2"
    REST_URL = "https://www.deribit.com/api/v2"
    
    def __init__(self, client_id: str, client_secret: str):
        self.client_id = client_id
        self.client_secret = client_secret
        self.access_token = None
        self.token_expires = 0
        self.data_buffer = []
        
    def _generate_auth_signature(self, timestamp: int) -> str:
        """Generate HMAC-SHA256 signature for authentication"""
        nonce = str(timestamp)
        string_to_sign = f"{self.client_id}\n{timestamp}\n{nonce}"
        signature = hmac.new(
            self.client_secret.encode(),
            string_to_sign.encode(),
            hashlib.sha256
        ).hexdigest()
        return signature
    
    async def authenticate(self) -> Dict:
        """Authenticate with Deribit API"""
        timestamp = int(time.time() * 1000)
        signature = self._generate_auth_signature(timestamp)
        
        payload = {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "public/auth",
            "params": {
                "grant_type": "client_credentials",
                "client_id": self.client_id,
                "client_secret": self.client_secret,
                "timestamp": timestamp,
                "signature": signature
            }
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(self.REST_URL, json=payload) as resp:
                result = await resp.json()
                if "result" in result:
                    self.access_token = result["result"]["access_token"]
                    self.token_expires = time.time() + result["result"]["expires_in"]
                return result
    
    async def get_option_chain(self, instrument: str = "BTC") -> pd.DataFrame:
        """
        Fetch complete option chain for BTC or ETH
        Returns: DataFrame with strike, expiry, IV, delta, gamma, etc.
        """
        if not self.access_token or time.time() > self.token_expires:
            await self.authenticate()
        
        # Get all instruments for BTC options
        instruments_params = {
            "jsonrpc": "2.0",
            "id": 2,
            "method": "public/get_instruments",
            "params": {
                "currency": instrument,
                "kind": "option",
                "expired": False
            }
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(self.REST_URL, json=instruments_params) as resp:
                result = await resp.json()
                instruments = result.get("result", [])
        
        # Fetch orderbook for each instrument (simplified for demo)
        chain_data = []
        for instr in instruments[:20]:  # Limit for demo
            orderbook = await self._get_orderbook(instr["instrument_name"])
            if orderbook:
                chain_data.append(self._parse_option_data(instr, orderbook))
        
        df = pd.DataFrame(chain_data)
        return df
    
    async def _get_orderbook(self, instrument_name: str) -> Optional[Dict]:
        """Fetch orderbook for a specific option"""
        params = {
            "jsonrpc": "2.0",
            "id": 3,
            "method": "public/get_order_book",
            "params": {"instrument_name": instrument_name}
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(self.REST_URL, json=params) as resp:
                result = await resp.json()
                return result.get("result")
    
    def _parse_option_data(self, instrument: Dict, orderbook: Dict) -> Dict:
        """Parse raw orderbook data into structured option data"""
        best_bid = orderbook.get("best_bid_price", 0)
        best_ask = orderbook.get("best_ask_price", 0)
        mid_price = (best_bid + best_ask) / 2 if best_bid and best_ask else 0
        
        return {
            "instrument_name": instrument["instrument_name"],
            "strike": instrument["strike"],
            "expiry": instrument["expiration_timestamp"],
            "option_type": "call" if instrument["option_type"] == "call" else "put",
            "bid": best_bid,
            "ask": best_ask,
            "mid": mid_price,
            "mark": orderbook.get("mark_price", mid_price),
            "open_interest": orderbook.get("open_interest", 0),
            "volume": orderbook.get("stats", {}).get("volume", 0),
            "timestamp": datetime.now().isoformat()
        }
    
    def calculate_implied_volatility(
        self, 
        S: float,      # Spot price
        K: float,      # Strike price
        T: float,      # Time to expiry (years)
        r: float,      # Risk-free rate
        market_price: float,  # Observed option price
        option_type: str = "call"
    ) -> float:
        """
        Calculate Implied Volatility using Newton-Raphson method
        Black-Scholes model
        """
        from scipy.stats import norm
        
        def black_scholes_call(S, K, T, r, sigma):
            d1 = (np.log(S/K) + (r + sigma**2/2)*T) / (sigma*np.sqrt(T))
            d2 = d1 - sigma*np.sqrt(T)
            return S*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2)
        
        def vega(S, K, T, r, sigma):
            d1 = (np.log(S/K) + (r + sigma**2/2)*T) / (sigma*np.sqrt(T))
            return S * np.sqrt(T) * norm.pdf(d1)
        
        # Newton-Raphson iteration
        sigma = 0.5  # Initial guess (50% IV)
        tol = 1e-6
        max_iter = 100
        
        for _ in range(max_iter):
            if option_type == "call":
                price = black_scholes_call(S, K, T, r, sigma)
            else:
                price = black_scholes_call(S, K, T, r, sigma) - S + K*np.exp(-r*T)
            
            diff = market_price - price
            
            if abs(diff) < tol:
                break
            
            vega_val = vega(S, K, T, r, sigma)
            if vega_val < 1e-10:
                break
                
            sigma += diff / vega_val
            sigma = max(0.01, min(sigma, 5.0))  # Bound IV between 1% and 500%
        
        return sigma


Usage Example

async def main():
    collector = DeribitOptionsCollector(
        client_id="YOUR_DERIBIT_CLIENT_ID",
        client_secret="YOUR_DERIBIT_CLIENT_SECRET"
    )
    
    await collector.authenticate()
    chain_df = await collector.get_option_chain("BTC")
    
    # Calculate IV for each option
    btc_spot = 67500  # Example BTC price
    for idx, row in chain_df.iterrows():
        T = (row['expiry'] / 1000 - time.time()) / (365 * 24 * 3600)
        if T > 0:
            iv = collector.calculate_implied_volatility(
                S=btc_spot,
                K=row['strike'],
                T=T,
                r=0.05,
                market_price=row['mid'],
                option_type=row['option_type']
            )
            chain_df.loc[idx, 'implied_volatility'] = iv
    
    print(chain_df[['instrument_name', 'strike', 'implied_volatility', 'open_interest']])
    
asyncio.run(main())

Code 2: HolySheep AI Integration Cho Implied Volatility Analysis

"""
HolySheep AI Integration for Deribit Options Analysis
Enhanced with NLP queries and automated insights
Base URL: https://api.holysheep.ai/v1
"""

import aiohttp
import json
import pandas as pd
from datetime import datetime

class HolySheepOptionsAnalyzer:
    """
    Integrate HolySheep AI for advanced options analysis
    Benefits: 85%+ cost savings, WeChat/Alipay support, <50ms latency
    """
    
    BASE_URL = "https://api.holysheep.ai/v1"
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    async def analyze_volatility_smile(
        self, 
        option_chain_df: pd.DataFrame,
        underlying_price: float,
        model: str = "deepseek-v3"
    ) -> Dict:
        """
        Use HolySheep AI to analyze volatility smile and surface
        Models available: gpt-4.1 ($8/MTok), claude-sonnet-4.5 ($15/MTok),
                          gemini-2.5-flash ($2.50/MTok), deepseek-v3 ($0.42/MTok)
        """
        
        # Prepare data for AI analysis
        strike_range = option_chain_df['strike'].max() - option_chain_df['strike'].min()
        atm_options = option_chain_df[
            (option_chain_df['strike'] > underlying_price * 0.95) &
            (option_chain_df['strike'] < underlying_price * 1.05)
        ]
        
        prompt = f"""
Bạn là chuyên gia phân tích quyền chọn BTC. Phân tích dữ liệu sau:

Thông tin thị trường:
- Giá BTC hiện tại: ${underlying_price:,.0f}
- Số quyền chọn trong chain: {len(option_chain_df)}
- Tỷ lệ Call/Put: {len(option_chain_df[option_chain_df['option_type']=='call'])}/{len(option_chain_df[option_chain_df['option_type']=='put'])}

ATM Options IV Analysis:
{atm_options[['strike', 'mid', 'implied_volatility']].to_string()}

Hãy phân tích:
1. Volatility Skew - Độ nghiêng của IV giữa ITM và OTM
2. Risk Reversal - Chiến lược recommended
3. IV Term Structure - So sánh IV giữa các expiry
4. Arbitrage opportunities nếu có
"""
        
        payload = {
            "model": model,
            "messages": [
                {"role": "system", "content": "Bạn là chuyên gia phân tích quyền chọn crypto với 10 năm kinh nghiệm."},
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.3,
            "max_tokens": 2000
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.BASE_URL}/chat/completions",
                headers=self.headers,
                json=payload
            ) as resp:
                result = await resp.json()
                return {
                    "analysis": result.get("choices", [{}])[0].get("message", {}).get("content"),
                    "usage": result.get("usage", {}),
                    "model": model,
                    "cost": self._calculate_cost(result.get("usage", {}), model)
                }
    
    async def generate_backtest_report(
        self,
        historical_iv: List[Dict],
        strategy_params: Dict,
        model: str = "gpt-4.1"
    ) -> str:
        """
        Generate automated backtest report using AI
        Compare performance with benchmark strategies
        """
        
        prompt = f"""
Tạo báo cáo backtest chi tiết cho chiến lược straddle straddle trên BTC Options.

Historical IV Data:
{json.dumps(historical_iv[:10], indent=2)}

Strategy Parameters:
- Entry IV threshold: {strategy_params.get('entry_iv', 'N/A')}
- Exit IV threshold: {strategy_params.get('exit_iv', 'N/A')}
- Holding period: {strategy_params.get('holding_days', 'N/A')} days

Yêu cầu:
1. Tính Sharpe Ratio, Max Drawdown, Win Rate
2. So sánh với buy-and-hold strategy
3. Risk-adjusted returns
4. Recommendations cho việc tối ưu hóa
"""
        
        payload = {
            "model": model,
            "messages": [
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.2,
            "max_tokens": 3000
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.BASE_URL}/chat/completions",
                headers=self.headers,
                json=payload
            ) as resp:
                result = await resp.json()
                return result.get("choices", [{}])[0].get("message", {}).get("content", "")
    
    async def natural_language_query(
        self,
        query: str,
        context_data: pd.DataFrame
    ) -> str:
        """
        Natural language query on options data
        Example: "So sánh IV của BTC 1 tuần vs 2 tuần expiry"
        """
        
        context_str = f"""
Dữ liệu Options BTC:
- Tổng số contracts: {len(context_data)}
- Expiry dates: {context_data['expiry'].unique().tolist()[:5]}
- Strike range: ${context_data['strike'].min():,.0f} - ${context_data['strike'].max():,.0f}
- Average IV: {context_data['implied_volatility'].mean():.2%}
"""
        
        payload = {
            "model": "deepseek-v3",  # Cost-effective for Q&A
            "messages": [
                {"role": "system", "content": "Trả lời bằng tiếng Việt, ngắn gọn và chính xác."},
                {"role": "user", "content": f"Context:\n{context_str}\n\nQuestion: {query}"}
            ],
            "temperature": 0.1
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.BASE_URL}/chat/completions",
                headers=self.headers,
                json=payload
            ) as resp:
                result = await resp.json()
                return result.get("choices", [{}])[0].get("message", {}).get("content", "")
    
    def _calculate_cost(self, usage: Dict, model: str) -> Dict:
        """Calculate API cost based on model pricing"""
        model_prices = {
            "gpt-4.1": 8.0,           # $8/MTok
            "claude-sonnet-4.5": 15.0, # $15/MTok
            "gemini-2.5-flash": 2.50,  # $2.50/MTok
            "deepseek-v3": 0.42        # $0.42/MTok
        }
        
        price = model_prices.get(model, 8.0)
        prompt_tokens = usage.get("prompt_tokens", 0)
        completion_tokens = usage.get("completion_tokens", 0)
        
        total_cost = (prompt_tokens + completion_tokens) / 1_000_000 * price
        
        return {
            "model": model,
            "price_per_mtok": f"${price}",
            "prompt_tokens": prompt_tokens,
            "completion_tokens": completion_tokens,
            "total_cost_usd": f"${total_cost:.6f}"
        }


Usage Example

async def main():
    analyzer = HolySheepOptionsAnalyzer(api_key="YOUR_HOLYSHEEP_API_KEY")
    
    # Sample option chain data
    sample_data = pd.DataFrame({
        'strike': [65000, 66000, 67000, 68000, 69000],
        'expiry': [datetime.now().timestamp() * 1000 + 7*86400*1000] * 5,
        'option_type': ['put', 'call', 'call', 'call', 'call'],
        'mid': [1500, 2500, 3500, 2800, 1800],
        'implied_volatility': [0.65, 0.72, 0.75, 0.68, 0.58]
    })
    
    # Analyze volatility smile
    result = await analyzer.analyze_volatility_smile(
        option_chain_df=sample_data,
        underlying_price=67000,
        model="deepseek-v3"  # Most cost-effective
    )
    
    print("=== Volatility Analysis ===")
    print(result['analysis'])
    print(f"\nToken Usage: {result['usage']}")
    print(f"Cost: {result['cost']}")
    
    # Natural language query
    answer = await analyzer.natural_language_query(
        query="IV hiện tại cao hơn hay thấp hơn mức trung bình 30 ngày?",
        context_data=sample_data
    )
    print(f"\n=== NL Query Result ===\n{answer}")

asyncio.run(main())

Tardis Machine Data Source Comparison

Qua kinh nghiệm thực chiến với cả Tardis và Deribit API, tôi nhận thấy một số khác biệt quan trọng:

Ưu Điểm Của Tardis Machine

Nhược Điểm Của Tardis Machine

Giải Pháp HolySheep: Best of Both Worlds

Kết hợp Deribit WebSocket cho real-time data và HolySheep AI cho analysis, bạn có được:

"""
Hybrid Data Pipeline: Deribit + HolySheep AI
Optimal cost-performance balance for retail traders
"""

import asyncio
import aiohttp
from typing import List, Dict
import pandas as pd

class HybridDataPipeline:
    """
    Combine Deribit real-time WebSocket with HolySheep AI analysis
    Total cost: ~$0.50/month vs $99+ for Tardis
    """
    
    HOLYSHEEP_URL = "https://api.holysheep.ai/v1"
    
    def __init__(self, holy_sheep_key: str):
        self.holy_sheep_key = holy_sheep_key
        self.headers = {
            "Authorization": f"Bearer {holy_sheep_key}",
            "Content-Type": "application/json"
        }
    
    async def get_historical_volatility(
        self, 
        symbol: str = "BTC",
        days: int = 30
    ) -> pd.DataFrame:
        """
        Fetch historical volatility from Deribit public API
        No authentication required for public endpoints
        """
        
        # Fetch BTC historical volatility via Deribit
        url = f"https://www.deribit.com/api/v2/public/get_volatility_history"
        params = {
            "currency": symbol,
            "resolution": "1D",
            "from": int(pd.Timestamp.now().timestamp()) - days * 86400,
            "to": int(pd.Timestamp.now().timestamp())
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.get(url, params=params) as resp:
                data = await resp.json()
                result = data.get("result", [])
        
        if not result:
            # Fallback: calculate from spot data
            return await self._calculate_hist_vol_from_spot(symbol, days)
        
        df = pd.DataFrame(result)
        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='s')
        return df
    
    async def _calculate_hist_vol_from_spot(
        self, 
        symbol: str, 
        days: int
    ) -> pd.DataFrame:
        """
        Fallback: Calculate historical volatility from spot prices
        """
        # This is a simplified version
        # In production, you'd use a proper data source
        return pd.DataFrame({
            'timestamp': pd.date_range(end=pd.Timestamp.now(), periods=days),
            'volatility': [0.65 + (i % 10) * 0.02 for i in range(days)]
        })
    
    async def ai_powered_analysis(
        self,
        historical_vol: pd.DataFrame,
        option_chain: pd.DataFrame
    ) -> Dict:
        """
        Use HolySheep AI for comprehensive analysis
        DeepSeek V3: $0.42/MTok — 96% cheaper than Claude Sonnet 4.5
        """
        
        prompt = f"""
Phân tích toàn diện chiến lược Options BTC:

Historical Volatility (30 days):
{historical_vol.tail(10).to_string()}

Current Option Chain Summary:
- ATM Strike: {option_chain['strike'].iloc[len(option_chain)//2] if len(option_chain) > 0 else 'N/A'}
- Front Month IV: {option_chain['implied_volatility'].mean():.2%} average
- Put/Call Ratio: {len(option_chain[option_chain['option_type']=='put'])/max(1, len(option_chain[option_chain['option_type']=='call'])):.2f}

Trả lời bằng tiếng Việt:
1. Đánh giá IV Rank (cao/thấp so với lịch sử)
2. Recommended strategy (Straddle, Strangle, Iron Condor, etc.)
3. Risk management guidelines
4. Position sizing recommendations
"""
        
        payload = {
            "model": "deepseek-v3",  # Best cost-efficiency
            "messages": [
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.3,
            "max_tokens": 2500
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(
                f"{self.HOLYSHEEP_URL}/chat/completions",
                headers=self.headers,
                json=payload
            ) as resp:
                result = await resp.json()
                return {
                    "insights": result.get("choices", [{}])[0].get("message", {}).get("content"),
                    "model": "deepseek-v3",
                    "estimated_cost": "$0.0001"  # ~2500 tokens at $0.42/MTok
                }


Production Usage

async def main():
    pipeline = HybridDataPipeline(holy_sheep_key="YOUR_HOLYSHEEP_API_KEY")
    
    # Get historical volatility
    hist_vol = await pipeline.get_historical_volatility(days=30)
    
    # Sample option chain
    sample_chain = pd.DataFrame({
        'strike': [65000, 67000, 69000],
        'implied_volatility': [0.68, 0.75, 0.62],
        'option_type': ['put', 'call', 'call']
    })
    
    # Get AI-powered analysis
    analysis = await pipeline.ai_powered_analysis(hist_vol, sample_chain)
    
    print("=== AI Analysis Result ===")
    print(analysis['insights'])
    print(f"\nCost: {analysis['estimated_cost']} (vs $0.10+ for equivalent Tardis query)")

asyncio.run(main())

Backtest Engine Cho Implied Volatility Strategies

"""
Implied Volatility Backtest Engine
Test straddle, strangle, iron condor strategies on Deribit BTC options
"""

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from typing import List, Dict, Tuple

class IVBacktestEngine:
    """
    Backtest options strategies using historical IV data
    Metrics: Sharpe, Max Drawdown, Win Rate, Profit Factor
    """
    
    def __init__(self, initial_capital: float = 100000):
        self.initial_capital = initial_capital
        self.capital = initial_capital
        self.trades = []
        self.equity_curve = []
    
    def backtest_straddle(
        self,
        df: pd.DataFrame,
        iv_entry_threshold: float = 0.20,
        iv_exit_threshold: float = 0.10,
        holding_days: int = 7
    ) -> Dict:
        """
        Backtest long straddle strategy based on IV levels
        
        Strategy:
        - Enter when IV Rank > entry_threshold
        - Exit when IV drops below exit_threshold OR holding_days reached
        """
        
        df = df.sort_values('timestamp').copy()
        position = None
        entry_price = 0
        entry_iv = 0
        
        for i, row in df.iterrows():
            current_iv = row.get('iv', 0)
            
            if position is None:
                # Check entry conditions
                if current

Tài nguyên liên quan
Bài viết liên quan