Năm 2024, khi thị trường phái sinh tiền mã hóa bước vào giai đoạn biến động mạnh với khối lượng giao dịch futures vượt 100 tỷ USD mỗi ngày, một nhà phân tích quantitative tại Singapore — giả sử tên là Minh — nhận ra rằng việc hiểu rõ cấu trúc quyền chọn (options) và funding rate có thể giúp dự đoán đảo chiều thị trường với độ chính xác cao hơn. Tuy nhiên, dữ liệu phái sinh chất lượng cao thường có chi phí rất đắt đỏ từ các nhà cung cấp như CryptoCompare, Kaiko hay CoinAPI. Minh đã tìm thấy Tardis (tardis.dev) — một nguồn cung cấp dữ liệu tick-level cho derivatives với định dạng CSV dễ xử lý, hoàn toàn miễn phí cho tier cơ bản. Bài viết này sẽ hướng dẫn bạn cách khai thác Tardis CSV dataset để phân tích options chain và funding rates, đồng thời tích hợp HolySheep AI để xử lý và diễn giải dữ liệu bằng AI.
Tardis CSV Dataset: Nguồn Dữ Liệu Phái Sinh Chất Lượng Cao
Tardis cung cấp dữ liệu historical và real-time cho hơn 20 sàn phái sinh, bao gồm Binance Futures, Bybit, OKX, Deribit, CME Group. Điểm mạnh của Tardis so với các đối thủ nằm ở:
- Tick-level granularity: Dữ liệu giao dịch với độ phân giải microsecond
- Options data: Chaining options với Greeks (delta, gamma, theta, vega)
- Funding rate history: Lịch sử funding rate theo thời gian thực
- CSV export: Không cần API key cho tier miễn phí, chỉ cần download trực tiếp
- Multi-exchange: Hỗ trợ so sánh cross-exchange dễ dàng
Cách Tải Dữ Liệu Tardis CSV
Tardis cung cấp trang web tải trực tiếp tại tardis.dev. Bạn có thể chọn:
- Exchange: Binance Futures, Bybit, OKX, Deribit...
- Data type: trades, quotes, options, funding, liquidations
- Date range: Chọn khoảng thời gian cần phân tích
- Symbol: BTC-PERP, ETH-PERP, BTC-OPTIONS...
Sau đây là script Python để tự động hóa việc tải dữ liệu từ Tardis:
# tardis_data_loader.py
import requests
import pandas as pd
from datetime import datetime, timedelta
import time
import os
class TardisDataLoader:
"""
Tardis CSV Data Loader - Tự động tải dữ liệu phái sinh từ Tardis
Hỗ trợ: trades, quotes, options, funding rates, liquidations
"""
BASE_URL = "https://tardis.dev/downloads"
SUPPORTED_EXCHANGES = [
'binance-futures',
'bybit',
'okx',
'deribit',
'binance-options',
'phemex'
]
DATA_TYPES = [
'trades',
'quotes',
'options',
'funding',
'liquidations'
]
def __init__(self, output_dir='./tardis_data'):
self.output_dir = output_dir
os.makedirs(output_dir, exist_ok=True)
def download_options_data(self, exchange, symbol, start_date, end_date):
"""
Tải dữ liệu quyền chọn (options) từ Tardis
"""
# URL pattern: https://tardis.dev/downloads/[exchange]/[data_type]/[date].csv.bz2
date_range = self._generate_date_range(start_date, end_date)
all_data = []
for date in date_range:
url = f"{self.BASE_URL}/{exchange}/options/{date}.csv.bz2"
local_path = os.path.join(self.output_dir, f"options_{exchange}_{date}.csv.bz2")
print(f"Tải: {url}")
try:
response = requests.get(url, timeout=60)
if response.status_code == 200:
# Giải nén và xử lý trực tiếp
import bz2
import io
with bz2.open(io.BytesIO(response.content), 'rt') as f:
df = pd.read_csv(f)
# Lọc theo symbol nếu cần
if 'symbol' in df.columns:
df = df[df['symbol'].str.contains(symbol, case=False, na=False)]
all_data.append(df)
print(f" ✓ Đã tải {len(df)} records")
else:
print(f" ✗ Lỗi HTTP {response.status_code}")
time.sleep(0.5) # Tránh overload server
except Exception as e:
print(f" ✗ Lỗi: {e}")
continue
if all_data:
combined_df = pd.concat(all_data, ignore_index=True)
output_file = os.path.join(self.output_dir, f"options_{exchange}_{symbol}_{start_date}_{end_date}.csv")
combined_df.to_csv(output_file, index=False)
print(f"\n✓ Đã lưu: {output_file} ({len(combined_df)} total records)")
return combined_df
return None
def download_funding_data(self, exchange, symbols, start_date, end_date):
"""
Tải dữ liệu funding rate từ Tardis
"""
date_range = self._generate_date_range(start_date, end_date)
all_data = []
for date in date_range:
url = f"{self.BASE_URL}/{exchange}/funding/{date}.csv.bz2"
print(f"Tải funding: {url}")
try:
response = requests.get(url, timeout=60)
if response.status_code == 200:
import bz2
import io
with bz2.open(io.BytesIO(response.content), 'rt') as f:
df = pd.read_csv(f)
if 'symbol' in df.columns:
df = df[df['symbol'].isin(symbols)]
all_data.append(df)
print(f" ✓ {len(df)} records")
time.sleep(0.5)
except Exception as e:
print(f" ✗ Lỗi: {e}")
continue
if all_data:
combined_df = pd.concat(all_data, ignore_index=True)
output_file = os.path.join(self.output_dir, f"funding_{exchange}_{start_date}_{end_date}.csv")
combined_df.to_csv(output_file, index=False)
print(f"\n✓ Đã lưu: {output_file}")
return combined_df
return None
def _generate_date_range(self, start_date, end_date):
"""Sinh danh sách ngày từ start đến end"""
dates = []
current = datetime.strptime(start_date, '%Y-%m-%d')
end = datetime.strptime(end_date, '%Y-%m-%d')
while current <= end:
dates.append(current.strftime('%Y-%m-%d'))
current += timedelta(days=1)
return dates
=== SỬ DỤNG ===
if __name__ == "__main__":
loader = TardisDataLoader(output_dir='./tardis_derivatives')
# Tải 7 ngày options BTC trên Deribit
print("=== Tải Options Data ===")
options_df = loader.download_options_data(
exchange='deribit',
symbol='BTC',
start_date='2024-01-15',
end_date='2024-01-21'
)
# Tải funding rates từ Binance Futures
print("\n=== Tải Funding Rates ===")
funding_df = loader.download_funding_data(
exchange='binance-futures',
symbols=['BTC-PERP', 'ETH-PERP', 'SOL-PERP'],
start_date='2024-01-01',
end_date='2024-01-31'
)
print("\n=== Hoàn tất! ===")Phân Tích Options Chain Với HolySheep AI
Sau khi tải dữ liệu, bước tiếp theo là phân tích và diễn giải. Ở đây, HolySheep AI với chi phí chỉ $0.42/MTok (DeepSeek V3.2) hoặc $2.50/MTok (Gemini 2.5 Flash) sẽ giúp bạn xử lý hàng triệu rows data một cách hiệu quả về chi phí. Dưới đây là pipeline hoàn chỉnh:
# options_analysis_pipeline.py
import pandas as pd
import numpy as np
from datetime import datetime
import requests
import json
=== HOLYSHEEP AI CONFIGURATION ===
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY" # Thay thế bằng API key của bạn
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1" # LUÔN LUÔN dùng HolySheep endpoint
class OptionsChainAnalyzer:
"""
Phân tích Options Chain từ dữ liệu Tardis
Tính toán: Open Interest, Max Pain, Put/Call Ratio, Greeks Summary
"""
def __init__(self, api_key):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
def load_tardis_options(self, csv_path):
"""Load dữ liệu options từ file CSV của Tardis"""
df = pd.read_csv(csv_path)
# Tardis options columns: symbol, date, expiry, strike, option_type,
# open_interest, volume, last_price, bid, ask, delta, gamma, theta, vega
print(f"Loaded {len(df)} options records")
print(f"Columns: {df.columns.tolist()}")
return df
def calculate_max_pain(self, df):
"""
Tính Max Pain - Mức giá mà tại đó tổng thiệt hại của options holders cao nhất
"""
if 'strike' not in df.columns or 'open_interest' not in df.columns:
raise ValueError("Data thiếu columns cần thiết: strike, open_interest")
# Lấy expiry gần nhất
latest_expiry = df['expiry'].max()
expiry_options = df[df['expiry'] == latest_expiry]
strikes = expiry_options['strike'].unique()
strike_prices = expiry_options['strike'].values
pain_data = []
for strike in strikes:
# Tính intrinsic value loss at this strike
call_pain = 0
put_pain = 0
# Calls: holders lose when price drops below strike
calls = expiry_options[expiry_options['option_type'] == 'call']
if 'open_interest' in calls.columns:
call_pain = (calls['strike'] - strike).clip(lower=0).fillna(0) * calls['open_interest']
call_pain = call_pain.sum()
# Puts: holders lose when price rises above strike
puts = expiry_options[expiry_options['option_type'] == 'put']
if 'open_interest' in puts.columns:
put_pain = (strike - puts['strike']).clip(lower=0).fillna(0) * puts['open_interest']
put_pain = put_pain.sum()
pain_data.append({
'strike': strike,
'total_pain': call_pain + put_pain
})
pain_df = pd.DataFrame(pain_data)
max_pain_strike = pain_df.loc[pain_df['total_pain'].idxmin(), 'strike']
return max_pain_strike, pain_df
def calculate_put_call_ratio(self, df):
"""Tính Put/Call Ratio từ Open Interest và Volume"""
if 'option_type' not in df.columns:
return None
calls = df[df['option_type'] == 'call']
puts = df[df['option_type'] == 'put']
# OI-based ratio
call_oi = calls['open_interest'].sum() if 'open_interest' in calls.columns else 0
put_oi = puts['open_interest'].sum() if 'open_interest' in puts.columns else 0
# Volume-based ratio
call_vol = calls['volume'].sum() if 'volume' in calls.columns else 0
put_vol = puts['volume'].sum() if 'volume' in puts.columns else 0
return {
'oi_ratio': put_oi / call_oi if call_oi > 0 else 0,
'volume_ratio': put_vol / call_vol if call_vol > 0 else 0,
'call_oi': call_oi,
'put_oi': put_oi,
'call_vol': call_vol,
'put_vol': put_vol
}
def analyze_greeks_exposure(self, df):
"""Phân tích Greeks exposure của toàn bộ chain"""
greeks = ['delta', 'gamma', 'theta', 'vega']
result = {}
for greek in greeks:
if greek in df.columns:
result[f'{greek}_total'] = df[greek].sum()
result[f'{greek}_call'] = df[df['option_type'] == 'call'][greek].sum()
result[f'{greek}_put'] = df[df['option_type'] == 'put'][greek].sum()
return result
def generate_analysis_summary(self, df):
"""Tạo summary report cho phân tích options"""
summary = {
'total_records': len(df),
'unique_symbols': df['symbol'].nunique() if 'symbol' in df.columns else 0,
'date_range': f"{df['date'].min()} to {df['date'].max()}" if 'date' in df.columns else 'N/A'
}
# Max Pain
try:
max_pain, pain_df = self.calculate_max_pain(df)
summary['max_pain'] = max_pain
except:
summary['max_pain'] = 'N/A'
# Put/Call Ratio
pcr = self.calculate_put_call_ratio(df)
if pcr:
summary.update(pcr)
# Greeks
greeks = self.analyze_greeks_exposure(df)
summary.update(greeks)
return summary
def query_ai_interpretation(self, summary_data):
"""
Gửi dữ liệu phân tích đến HolySheep AI để diễn giải
Tiết kiệm 85%+ so với OpenAI: DeepSeek V3.2 chỉ $0.42/MTok
"""
prompt = f"""
Bạn là chuyên gia phân tích phái sinh tiền mã hóa. Hãy diễn giải dữ liệu options sau:
Dữ liệu phân tích:
{json.dumps(summary_data, indent=2)}
Hãy cung cấp:
1. Giải thích Put/Call Ratio và ý nghĩa (bullish/bearish signal)
2. Phân tích Max Pain price so với giá thị trường hiện tại
3. Greeks exposure analysis - what does it mean for market direction?
4. Khuyến nghị trading ngắn hạn dựa trên dữ liệu
5. Rủi ro cần lưu ý
Format response bằng tiếng Việt, có bullet points.
"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json={
"model": "deepseek-chat-v3.2", # Model rẻ nhất, hiệu năng cao
"messages": [
{"role": "system", "content": "Bạn là chuyên gia phân tích phái sinh tiền mã hóa."},
{"role": "user", "content": prompt}
],
"temperature": 0.3,
"max_tokens": 2000
},
timeout=30
)
if response.status_code == 200:
result = response.json()
return result['choices'][0]['message']['content']
else:
raise Exception(f"HolySheep API Error: {response.status_code} - {response.text}")
=== SỬ DỤNG ===
if __name__ == "__main__":
analyzer = OptionsChainAnalyzer(api_key=HOLYSHEEP_API_KEY)
# Load dữ liệu
print("=== Phân tích Options Chain ===")
options_df = analyzer.load_tardis_options('./tardis_derivatives/options_btc_jan.csv')
# Tạo summary
summary = analyzer.generate_analysis_summary(options_df)
print("\n📊 Summary:")
print(json.dumps(summary, indent=2))
# Gửi đến AI để diễn giải
print("\n🤖 Đang query HolySheep AI...")
interpretation = analyzer.query_ai_interpretation(summary)
print("\n📝 AI Interpretation:")
print(interpretation)Phân Tích Funding Rate Và Dự Đoán Đảo Chiều
Funding rate là chỉ báo quan trọng để xác định động lực thị trường. Khi funding rate quá cao (positive), đa số traders đang long — đây có thể là tín hiệu sắp correction. Ngược lại, funding rate âm sâu cho thấy áp lực short đang tích tụ.
# funding_rate_analysis.py
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import requests
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
class FundingRateAnalyzer:
"""
Phân tích Funding Rate để dự đoán đảo chiều thị trường
"""
def __init__(self, api_key):
self.api_key = api_key
self.base_url = HOLYSHEEP_BASE_URL
def load_funding_data(self, csv_path):
"""Load dữ liệu funding rate từ Tardis CSV"""
df = pd.read_csv(csv_path)
# Convert timestamp nếu cần
if 'timestamp' in df.columns:
df['datetime'] = pd.to_datetime(df['timestamp'], unit='ms')
elif 'date' in df.columns:
df['datetime'] = pd.to_datetime(df['date'])
return df
def calculate_funding_metrics(self, df, symbol):
"""Tính các metrics quan trọng từ funding rate"""
symbol_data = df[df['symbol'] == symbol].copy()
if len(symbol_data) == 0:
return None
# Sort theo thời gian
symbol_data = symbol_data.sort_values('datetime')
# Funding rate columns: symbol, timestamp, funding_rate, mark_price, index_price
metrics = {
'symbol': symbol,
'total_observations': len(symbol_data),
'date_range': f"{symbol_data['datetime'].min()} to {symbol_data['datetime'].max()}",
# Basic stats
'mean_funding': symbol_data['funding_rate'].mean(),
'median_funding': symbol_data['funding_rate'].median(),
'std_funding': symbol_data['funding_rate'].std(),
'min_funding': symbol_data['funding_rate'].min(),
'max_funding': symbol_data['funding_rate'].max(),
# Current funding
'current_funding': symbol_data['funding_rate'].iloc[-1],
# Funding trend (7-day)
'funding_7d_avg': symbol_data['funding_rate'].tail(7).mean(),
'funding_30d_avg': symbol_data['funding_rate'].tail(30).mean(),
# Funding regime
'positive_pct': (symbol_data['funding_rate'] > 0).mean() * 100,
'extreme_positive_pct': (symbol_data['funding_rate'] > 0.01).mean() * 100, # >1% là extreme
'extreme_negative_pct': (symbol_data['funding_rate'] < -0.01).mean() * 100,
# Historical extremes
'times_above_1pct': (symbol_data['funding_rate'] > 0.01).sum(),
'times_below_neg1pct': (symbol_data['funding_rate'] < -0.01).sum(),
}
return metrics
def detect_funding_regime_change(self, df, symbol, threshold=0.005):
"""
Phát hiện thay đổi regime của funding rate
Regime change = funding chuyển từ âm sang dương hoặc ngược lại đột ngột
"""
symbol_data = df[df['symbol'] == symbol].copy().sort_values('datetime')
if 'funding_rate' not in symbol_data.columns:
return []
changes = []
for i in range(1, len(symbol_data)):
prev_rate = symbol_data['funding_rate'].iloc[i-1]
curr_rate = symbol_data['funding_rate'].iloc[i]
# Regime change: từ âm sang dương hoặc dương sang âm với magnitude lớn
if (prev_rate < 0 and curr_rate > threshold) or (prev_rate > 0 and curr_rate < -threshold):
changes.append({
'datetime': symbol_data['datetime'].iloc[i],
'previous_rate': prev_rate,
'current_rate': curr_rate,
'change_type': 'neg_to_pos' if curr_rate > 0 else 'pos_to_neg',
'magnitude': abs(curr_rate - prev_rate)
})
return changes
def calculate_funding_premium(self, df, symbol):
"""
Tính Funding Premium = Chênh lệch funding rate giữa perpetual và quarterly
Premium cao = funding demand cao, có thể预示rekt
"""
# Lấy perpetual funding
perp_data = df[df['symbol'].str.contains('PERP', case=False, na=False)]
perp_funding = perp_data['funding_rate'].mean()
# Lấy quarterly futures funding (nếu có)
quarterly_data = df[df['symbol'].str.contains('-.*-[0-9]{2,4}', case=False, na=False)]
quarterly_funding = quarterly_data['funding_rate'].mean() if len(quarterly_data) > 0 else 0
premium = perp_funding - quarterly_funding
return {
'perp_avg_funding': perp_funding,
'quarterly_avg_funding': quarterly_funding,
'funding_premium': premium,
'premium_significance': 'High' if abs(premium) > 0.005 else 'Normal'
}
def generate_signals(self, df, symbols):
"""
Tạo trading signals dựa trên funding rate analysis
"""
signals = []
for symbol in symbols:
metrics = self.calculate_funding_metrics(df, symbol)
if metrics:
signal = {
'symbol': symbol,
'signal': 'NEUTRAL',
'confidence': 0,
'reasoning': []
}
# Signal 1: Extreme positive funding (potential top)
if metrics['current_funding'] > 0.01:
signal['signal'] = 'BEARISH'
signal['confidence'] += 30
signal['reasoning'].append("Funding rate > 1% - traders đang trả phí funding cao để hold long")
# Signal 2: Funding đang tăng nhanh
if metrics['funding_7d_avg'] > metrics['funding_30d_avg'] * 1.5:
signal['signal'] = 'BEARISH'
signal['confidence'] += 20
signal['reasoning'].append("Funding rate đang tăng nhanh - momentum bullish có thể suy yếu")
# Signal 3: Extreme negative funding (potential bottom)
if metrics['current_funding'] < -0.01:
signal['signal'] = 'BULLISH'
signal['confidence'] += 30
signal['reasoning'].append("Funding rate < -1% - traders đang được trả tiền để hold short")
# Signal 4: Funding chuyển từ âm sang dương
changes = self.detect_funding_regime_change(df, symbol)
recent_changes = [c for c in changes if (datetime.now() - c['datetime']).days <= 3]
if any(c['change_type'] == 'neg_to_pos' for c in recent_changes):
signal['signal'] = 'BEARISH'
signal['confidence'] += 25
signal['reasoning'].append("Funding vừa chuyển từ âm sang dương - short squeeze có thể xảy ra")
signals.append(signal)
return signals
def get_ai_trading_recommendation(self, signals, market_context=None):
"""
Sử dụng HolySheep AI để đưa ra khuyến nghị trading
Model DeepSeek V3.2: chỉ $0.42/MTok - tiết kiệm 85%+
"""
prompt = f"""
Bạn là chuyên gia phân tích thị trường phái sinh tiền mã hóa.
Dữ liệu Funding Rate Signals:
{signals}
Market Context (nếu có):
{market_context}
Hãy phân tích:
1. Tổng quan signals: đa số bullish hay bearish?
2. Confidence level của signals hiện tại
3. Khuyến nghị trading cụ thể: Entry, Stop Loss, Take Profit
4. Risk/Reward ratio
5. Timeframe phù hợp (scalp, swing, position)
6. Cảnh báo rủi ro quan trọng
Trả lời bằng tiếng Việt, có cấu trúc rõ ràng.
"""
response = requests.post(
f"{self.base_url}/chat/completions",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json={
"model": "deepseek-chat-v3.2",
"messages": [
{"role": "system", "content": "Bạn là chuyên gia phân tích phái sinh tiền mã hóa với kinh nghiệm 10 năm."},
{"role": "user", "content": prompt}
],
"temperature": 0.2,
"max_tokens": 2500
},
timeout=30
)
if response.status_code == 200:
return response.json()['choices'][0]['message']['content']
else:
raise Exception(f"HolySheep API Error: {response.status_code}")
=== SỬ DỤNG ===
if __name__ == "__main__":
analyzer = FundingRateAnalyzer(api_key=HOLYSHEEP_API_KEY)
# Load dữ liệu
funding_df = analyzer.load_funding_data('./tardis_derivatives/funding_binance_jan.csv')
# Phân tích từng cặp
symbols = ['BTC-PERP', 'ETH-PERP', 'SOL-PERP']
print("=== Funding Rate Analysis ===\n")
for symbol in symbols:
metrics = analyzer.calculate_funding_metrics(funding_df, symbol)
if metrics:
print(f"\n📊 {symbol}:")
print(f" Current Funding: {metrics['current_funding']*100:.4f}%")
print(f" 7D Average: {metrics['funding_7d_avg']*100:.4f}%")
print(f" 30D Average: {metrics['funding_30d_avg']*100:.4f}%")
print(f" Extreme Events: {metrics['times_above_1pct']} up, {metrics['times_below_neg1pct']} down")
# Tạo signals
signals = analyzer.generate_signals(funding_df, symbols)
# Get AI recommendation
print("\n\n🤖 Đang query HolySheep AI...")
recommendation = analyzer.get_ai_trading_recommendation(signals)
print("\n📝 AI Trading Recommendation:")
print(recommendation)Tích Hợp Đồng Thời Options Chain + Funding Rate
Điểm mạnh của phân tích toàn diện là kết hợp cả Options và Funding Rate để có cái nhìn 360°. Khi cả hai indicators cùng đưa ra tín hiệu giống nhau, confidence cao hơn đáng kể.
# combined_analysis_dashboard.py
import pandas as pd
import numpy as np
import requests
import json
from datetime import datetime
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
class CombinedDerivativesDashboard:
"""
Dashboard phân tích kết hợp Options + Funding Rate
Đưa ra composite signals với độ chính xác cao hơn
"""
def __init__(self, api_key):
self.api_key = api_key
self.base_url = HOLYSHEEP_BASE_URL
def calculate_composite_sentiment(self, options_metrics, funding_metrics):
"""
Tính Composite Sentiment Score từ cả Options và Funding
Score range: -100 (extremely bearish) to +100 (extremely bullish)
"""
sentiment_score = 0
factors = []
# === OPTIONS FACTORS ===
# PCR > 1.5 = bearish cho spot market = bullish signal cho short
if 'oi_ratio' in options_metrics:
pcr = options_metrics['oi_ratio']
if pcr > 1.5:
sentiment_score += 20
factors.append(f"PCR={pcr:.2f} (Bearish sentiment, expecting drop)")
elif pcr < 0.7:
sentiment_score -= 20
factors.append(f"PCR={pcr:.2f} (Bullish sentiment, expecting rally)")
# Max Pain analysis
if 'max_pain' in options_metrics:
factors.append(f"Max Pain: {options_metrics['max_pain']}")
# Net Delta Exposure
if 'delta_total' in options_metrics:
delta_total = options_metrics['delta_total']
if delta_total > 0:
sentiment_score += 15
factors.append(f"Positive Delta Exposure (+{delta_total:.2f})")
else:
sentiment_score -= 15
factors.append(f"Negative Delta Exposure ({delta_total:.2f})")
# === FUNDING FACTORS ===
# Funding rate analysis
if 'current_funding' in funding_metrics:
curr_funding = funding_metrics['current_funding']
if curr_funding > 0.005: # >0.5%
sentiment_score -= 25
factors.append(f"High Funding Rate ({curr_funding*100:.2f}%) - Longs paying premium")
elif curr_funding < -0.005: # <-0.5%
sentiment_score += 25
factors.append(f"Low Funding Rate ({curr_funding*100:.2f}%) - Shorts paying premium")
# Funding trend
if 'funding_7d_avg' in funding_metrics and 'funding_30d_avg' in funding_metrics:
funding_trend = funding_metrics['funding_7d_avg'] / funding_metrics['funding_30d_avg']
if funding_trend > 1.5:
sentiment_score -= 15
factors.append("Funding trending up - momentum weakening")
elif funding_trend < 0.5:
sentiment_score += 15
factors.append("Funding trending down - momentum building")
# Normalize score to -100 to +100
sentiment_score = max(-100, min(100, sentiment_score))
return {
'score': sentiment_score,
'interpretation': self