@intentsolutionsio/crypto-derivatives-tracker 1.0.0 → 1.0.3

package/skills/tracking-crypto-derivatives/scripts/funding_tracker.py

@@ -10,7 +10,6 @@ Tracks funding rates across exchanges with:
 """
 
 from dataclasses import dataclass
-from decimal import Decimal
 from typing import Dict, List, Optional
 from datetime import datetime
 
@@ -27,9 +26,9 @@ class FundingAnalysis:
     annualized_avg: float
     min_rate: FundingRate
     max_rate: FundingRate
-    spread: float               # Max - min rate
-    sentiment: str              # "bullish", "bearish", "neutral"
-    sentiment_strength: str     # "strong", "moderate", "weak"
+    spread: float  # Max - min rate
+    sentiment: str  # "bullish", "bearish", "neutral"
+    sentiment_strength: str  # "strong", "moderate", "weak"
     arbitrage_opportunity: bool
     arbitrage_spread: float
     timestamp: datetime
@@ -57,12 +56,12 @@ class FundingTracker:
     """
 
     # Funding rate interpretation thresholds
-    NEUTRAL_THRESHOLD = 0.005       # Below this is neutral
-    MODERATE_THRESHOLD = 0.03       # Below this is moderate
-    EXTREME_THRESHOLD = 0.08        # Above this is extreme
+    NEUTRAL_THRESHOLD = 0.005  # Below this is neutral
+    MODERATE_THRESHOLD = 0.03  # Below this is moderate
+    EXTREME_THRESHOLD = 0.08  # Above this is extreme
 
     # Arbitrage minimum spread
-    ARB_MIN_SPREAD = 0.02           # 0.02% minimum for arbitrage
+    ARB_MIN_SPREAD = 0.02  # 0.02% minimum for arbitrage
 
     def __init__(
         self,
@@ -188,17 +187,19 @@ class FundingTracker:
                 profit_daily = profit_8h * 3
                 profit_annual = profit_8h * 365 * 3
 
-                opportunities.append({
-                    "symbol": symbol,
-                    "long_exchange": analysis.min_rate.exchange,
-                    "long_rate": float(analysis.min_rate.rate),
-                    "short_exchange": analysis.max_rate.exchange,
-                    "short_rate": float(analysis.max_rate.rate),
-                    "spread": analysis.spread,
-                    "profit_8h_pct": round(profit_8h, 4),
-                    "profit_daily_pct": round(profit_daily, 4),
-                    "profit_annual_pct": round(profit_annual, 2),
-                })
+                opportunities.append(
+                    {
+                        "symbol": symbol,
+                        "long_exchange": analysis.min_rate.exchange,
+                        "long_rate": float(analysis.min_rate.rate),
+                        "short_exchange": analysis.max_rate.exchange,
+                        "short_rate": float(analysis.max_rate.rate),
+                        "spread": analysis.spread,
+                        "profit_8h_pct": round(profit_8h, 4),
+                        "profit_daily_pct": round(profit_daily, 4),
+                        "profit_annual_pct": round(profit_annual, 2),
+                    }
+                )
 
         # Sort by spread descending
         opportunities.sort(key=lambda x: x["spread"], reverse=True)
@@ -228,15 +229,17 @@ class FundingTracker:
             analysis = self.analyze(symbol)
 
             if abs(analysis.weighted_avg) >= threshold:
-                extreme.append({
-                    "symbol": symbol,
-                    "avg_rate": analysis.weighted_avg,
-                    "annualized": analysis.annualized_avg,
-                    "sentiment": analysis.sentiment,
-                    "strength": analysis.sentiment_strength,
-                    "signal": "short" if analysis.weighted_avg > 0 else "long",
-                    "signal_reason": "Contrarian: extreme funding often reverts",
-                })
+                extreme.append(
+                    {
+                        "symbol": symbol,
+                        "avg_rate": analysis.weighted_avg,
+                        "annualized": analysis.annualized_avg,
+                        "sentiment": analysis.sentiment,
+                        "strength": analysis.sentiment_strength,
+                        "signal": "short" if analysis.weighted_avg > 0 else "long",
+                        "signal_reason": "Contrarian: extreme funding often reverts",
+                    }
+                )
 
         # Sort by absolute rate descending
         extreme.sort(key=lambda x: abs(x["avg_rate"]), reverse=True)
@@ -262,10 +265,7 @@ def demo():
 
     for rate in sorted(analysis.rates, key=lambda r: r.rate, reverse=True):
         print(
-            f"{rate.exchange:<12} "
-            f"{float(rate.rate):>+9.4%} "
-            f"{rate.annualized:>+11.2f}% "
-            f"{rate.time_to_payment_str:>14}"
+            f"{rate.exchange:<12} {float(rate.rate):>+9.4%} {rate.annualized:>+11.2f}% {rate.time_to_payment_str:>14}"
         )
 
     print("-" * 50)
@@ -275,10 +275,10 @@ def demo():
     print(f"\nSentiment: {analysis.sentiment_strength.title()} {analysis.sentiment.title()}")
 
     if analysis.is_extreme:
-        print(f"\n⚠️  EXTREME FUNDING - Contrarian opportunity")
+        print("\n⚠️  EXTREME FUNDING - Contrarian opportunity")
 
     if analysis.arbitrage_opportunity:
-        print(f"\n💰 ARBITRAGE OPPORTUNITY")
+        print("\n💰 ARBITRAGE OPPORTUNITY")
         print(f"   Long on {analysis.min_rate.exchange} ({float(analysis.min_rate.rate):+.4%})")
         print(f"   Short on {analysis.max_rate.exchange} ({float(analysis.max_rate.rate):+.4%})")
         print(f"   Profit: {analysis.arbitrage_spread:.4%} per 8h")

package/skills/tracking-crypto-derivatives/scripts/liquidation_monitor.py

@@ -14,9 +14,7 @@ from decimal import Decimal
 from typing import Dict, List, Optional
 from datetime import datetime, timedelta
 
-from exchange_client import (
-    ExchangeClient, Liquidation, LiquidationLevel, Exchange
-)
+from exchange_client import ExchangeClient, Liquidation, LiquidationLevel
 
 
 @dataclass
@@ -32,7 +30,7 @@ class LiquidationSummary:
     recent_liquidations: List[Liquidation]
     long_levels: List[LiquidationLevel]
     short_levels: List[LiquidationLevel]
-    cascade_risk: str               # "low", "medium", "high", "critical"
+    cascade_risk: str  # "low", "medium", "high", "critical"
     nearest_long_level: Optional[LiquidationLevel]
     nearest_short_level: Optional[LiquidationLevel]
     timestamp: datetime
@@ -50,9 +48,9 @@ class LiquidationMonitor:
     """
 
     # Cascade risk thresholds (USD within 5% of price)
-    CRITICAL_THRESHOLD = 500_000_000    # $500M
-    HIGH_THRESHOLD = 200_000_000        # $200M
-    MEDIUM_THRESHOLD = 100_000_000      # $100M
+    CRITICAL_THRESHOLD = 500_000_000  # $500M
+    HIGH_THRESHOLD = 200_000_000  # $200M
+    MEDIUM_THRESHOLD = 100_000_000  # $100M
 
     def __init__(
         self,
@@ -91,9 +89,7 @@ class LiquidationMonitor:
                 current_price = Decimal("100")
 
         # Fetch recent liquidations
-        liquidations = self.client.get_recent_liquidations(
-            symbol, limit=100, min_value_usd=100000
-        )
+        liquidations = self.client.get_recent_liquidations(symbol, limit=100, min_value_usd=100000)
 
         # Fetch liquidation levels
         levels = self.client.get_liquidation_levels(symbol, current_price)
@@ -122,9 +118,7 @@ class LiquidationMonitor:
         nearest_short = short_levels[0] if short_levels else None
 
         # Assess cascade risk
-        cascade_risk = self._assess_cascade_risk(
-            current_price, long_levels, short_levels
-        )
+        cascade_risk = self._assess_cascade_risk(current_price, long_levels, short_levels)
 
         return LiquidationSummary(
             symbol=symbol,
@@ -207,22 +201,26 @@ class LiquidationMonitor:
         # Add long levels (below price)
         for level in summary.long_levels[:levels]:
             distance_pct = (float(current_price) - float(level.price)) / float(current_price) * 100
-            heatmap["long_levels"].append({
-                "price": float(level.price),
-                "value_usd": float(level.total_value_usd),
-                "distance_pct": round(distance_pct, 1),
-                "density": level.density,
-            })
+            heatmap["long_levels"].append(
+                {
+                    "price": float(level.price),
+                    "value_usd": float(level.total_value_usd),
+                    "distance_pct": round(distance_pct, 1),
+                    "density": level.density,
+                }
+            )
 
         # Add short levels (above price)
         for level in summary.short_levels[:levels]:
             distance_pct = (float(level.price) - float(current_price)) / float(current_price) * 100
-            heatmap["short_levels"].append({
-                "price": float(level.price),
-                "value_usd": float(level.total_value_usd),
-                "distance_pct": round(distance_pct, 1),
-                "density": level.density,
-            })
+            heatmap["short_levels"].append(
+                {
+                    "price": float(level.price),
+                    "value_usd": float(level.total_value_usd),
+                    "distance_pct": round(distance_pct, 1),
+                    "density": level.density,
+                }
+            )
 
         return heatmap
 
@@ -243,9 +241,7 @@ class LiquidationMonitor:
         Returns:
             List of large liquidations
         """
-        liquidations = self.client.get_recent_liquidations(
-            symbol, limit=limit * 2, min_value_usd=min_value_usd
-        )
+        liquidations = self.client.get_recent_liquidations(symbol, limit=limit * 2, min_value_usd=min_value_usd)
 
         # Filter by size and limit
         large = [l for l in liquidations if float(l.value_usd) >= min_value_usd]
@@ -294,10 +290,10 @@ def demo():
     print("-" * 60)
 
     # 24h totals
-    print(f"\n24h Liquidations:")
-    print(f"   Total:  ${float(summary.total_24h_usd)/1e6:,.1f}M")
-    print(f"   Longs:  ${float(summary.long_liquidations_usd)/1e6:,.1f}M")
-    print(f"   Shorts: ${float(summary.short_liquidations_usd)/1e6:,.1f}M")
+    print("\n24h Liquidations:")
+    print(f"   Total:  ${float(summary.total_24h_usd) / 1e6:,.1f}M")
+    print(f"   Longs:  ${float(summary.long_liquidations_usd) / 1e6:,.1f}M")
+    print(f"   Shorts: ${float(summary.short_liquidations_usd) / 1e6:,.1f}M")
 
     # Cascade risk
     risk_emoji = {
@@ -320,7 +316,7 @@ def demo():
         density_mark = "⚠️ " if level.density in ["high", "critical"] else ""
         print(
             f"  ${float(level.price):>10,.0f} {bar} "
-            f"${float(level.total_value_usd)/1e6:.0f}M {density_mark}{level.density.upper()}"
+            f"${float(level.total_value_usd) / 1e6:.0f}M {density_mark}{level.density.upper()}"
         )
 
     print(f"\nSHORT LIQUIDATIONS (above ${summary.current_price:,}):")
@@ -330,7 +326,7 @@ def demo():
         density_mark = "⚠️ " if level.density in ["high", "critical"] else ""
         print(
             f"  ${float(level.price):>10,.0f} {bar} "
-            f"${float(level.total_value_usd)/1e6:.0f}M {density_mark}{level.density.upper()}"
+            f"${float(level.total_value_usd) / 1e6:.0f}M {density_mark}{level.density.upper()}"
         )
 
     # Recent large liquidations
@@ -347,7 +343,7 @@ def demo():
                 f"{l['exchange']:<10} "
                 f"{l['side']:<6} "
                 f"${l['price']:>10,.0f} "
-                f"${l['value_usd']/1e6:>10.1f}M "
+                f"${l['value_usd'] / 1e6:>10.1f}M "
                 f"{l['time_ago']:>10}"
             )
 

package/skills/tracking-crypto-derivatives/scripts/oi_analyzer.py

@@ -30,8 +30,8 @@ class OIAnalysis:
     weighted_long_ratio: float
     dominant_exchange: str
     dominant_share: float
-    trend: str                  # "increasing", "decreasing", "stable"
-    trend_strength: str         # "strong", "moderate", "weak"
+    trend: str  # "increasing", "decreasing", "stable"
+    trend_strength: str  # "strong", "moderate", "weak"
     timestamp: datetime
 
     @property
@@ -55,13 +55,13 @@ class OIDivergence:
     """OI vs Price divergence signal."""
 
     symbol: str
-    oi_direction: str           # "up" or "down"
-    price_direction: str        # "up" or "down"
+    oi_direction: str  # "up" or "down"
+    price_direction: str  # "up" or "down"
     oi_change_pct: float
     price_change_pct: float
-    signal: str                 # "bullish", "bearish", "short_squeeze", "long_liquidation"
+    signal: str  # "bullish", "bearish", "short_squeeze", "long_liquidation"
     description: str
-    confidence: str             # "high", "medium", "low"
+    confidence: str  # "high", "medium", "low"
 
 
 class OIAnalyzer:
@@ -76,8 +76,8 @@ class OIAnalyzer:
     """
 
     # Trend thresholds
-    STRONG_CHANGE = 10.0        # >10% is strong
-    MODERATE_CHANGE = 5.0       # >5% is moderate
+    STRONG_CHANGE = 10.0  # >10% is strong
+    MODERATE_CHANGE = 5.0  # >5% is moderate
 
     def __init__(
         self,
@@ -117,17 +117,11 @@ class OIAnalyzer:
         total_contracts = sum(float(oi.oi_contracts) for oi in oi_list)
 
         # Calculate weighted averages
-        avg_24h = sum(
-            oi.change_24h_pct * float(oi.oi_usd) for oi in oi_list
-        ) / total_usd
-        avg_7d = sum(
-            oi.change_7d_pct * float(oi.oi_usd) for oi in oi_list
-        ) / total_usd
+        avg_24h = sum(oi.change_24h_pct * float(oi.oi_usd) for oi in oi_list) / total_usd
+        avg_7d = sum(oi.change_7d_pct * float(oi.oi_usd) for oi in oi_list) / total_usd
 
         # Weighted long ratio
-        weighted_long = sum(
-            oi.long_ratio * float(oi.oi_usd) for oi in oi_list
-        ) / total_usd
+        weighted_long = sum(oi.long_ratio * float(oi.oi_usd) for oi in oi_list) / total_usd
 
         # Find dominant exchange
         dominant = max(oi_list, key=lambda x: x.oi_usd)
@@ -258,13 +252,15 @@ class OIAnalyzer:
         shares = []
         for oi in analysis.exchanges:
             share = float(oi.oi_usd) / total * 100
-            shares.append({
-                "exchange": oi.exchange,
-                "oi_usd": float(oi.oi_usd),
-                "share_pct": round(share, 1),
-                "change_24h": oi.change_24h_pct,
-                "long_ratio": oi.long_ratio,
-            })
+            shares.append(
+                {
+                    "exchange": oi.exchange,
+                    "oi_usd": float(oi.oi_usd),
+                    "share_pct": round(share, 1),
+                    "change_24h": oi.change_24h_pct,
+                    "long_ratio": oi.long_ratio,
+                }
+            )
 
         return sorted(shares, key=lambda x: x["oi_usd"], reverse=True)
 
@@ -290,14 +286,14 @@ def demo():
         share = float(oi.oi_usd) / float(analysis.total_oi_usd) * 100
         print(
             f"{oi.exchange:<12} "
-            f"${float(oi.oi_usd)/1e9:>12.2f}B "
+            f"${float(oi.oi_usd) / 1e9:>12.2f}B "
             f"{oi.change_24h_pct:>+9.1f}% "
             f"{oi.change_7d_pct:>+9.1f}% "
             f"{share:>7.1f}%"
         )
 
     print("-" * 60)
-    print(f"\nTotal OI: ${float(analysis.total_oi_usd)/1e9:.2f}B")
+    print(f"\nTotal OI: ${float(analysis.total_oi_usd) / 1e9:.2f}B")
     print(f"24h Change: {analysis.avg_change_24h:+.1f}%")
     print(f"7d Change: {analysis.avg_change_7d:+.1f}%")
     print(f"\nLong/Short Ratio: {analysis.weighted_long_ratio:.2f} ({analysis.long_percentage:.1f}% long)")
@@ -314,7 +310,7 @@ def demo():
     divergence = analyzer.detect_divergence("BTC", price_change)
 
     if divergence:
-        print(f"\n🔍 Divergence Detected!")
+        print("\n🔍 Divergence Detected!")
         print(f"   OI:    {divergence.oi_direction} ({divergence.oi_change_pct:+.1f}%)")
         print(f"   Price: {divergence.price_direction} ({divergence.price_change_pct:+.1f}%)")
         print(f"   Signal: {divergence.signal.upper()}")

package/skills/tracking-crypto-derivatives/scripts/options_analyzer.py

@@ -23,13 +23,13 @@ class OptionsAnalysis:
 
     symbol: str
     snapshot: OptionsSnapshot
-    iv_interpretation: str          # "high", "normal", "low"
-    iv_percentile: float            # Estimated percentile (0-100)
-    sentiment_from_pcr: str         # "bullish", "bearish", "neutral"
-    sentiment_from_skew: str        # "bullish", "bearish", "neutral"
+    iv_interpretation: str  # "high", "normal", "low"
+    iv_percentile: float  # Estimated percentile (0-100)
+    sentiment_from_pcr: str  # "bullish", "bearish", "neutral"
+    sentiment_from_skew: str  # "bullish", "bearish", "neutral"
     overall_sentiment: str
-    max_pain_distance_pct: float    # Distance from current to max pain
-    expiry_pressure: str            # "high", "medium", "low"
+    max_pain_distance_pct: float  # Distance from current to max pain
+    expiry_pressure: str  # "high", "medium", "low"
     timestamp: datetime
 
 
@@ -40,8 +40,8 @@ class OptionsFlow:
     symbol: str
     expiry: str
     strike: Decimal
-    option_type: str                # "call" or "put"
-    side: str                       # "buy" or "sell"
+    option_type: str  # "call" or "put"
+    side: str  # "buy" or "sell"
     size_contracts: int
     premium_usd: Decimal
     iv_at_trade: float
@@ -65,8 +65,8 @@ class OptionsAnalyzer:
     LOW_IV = 40.0
 
     # Put/call interpretation
-    BEARISH_PCR = 1.2   # Above this is bearish
-    BULLISH_PCR = 0.7   # Below this is bullish
+    BEARISH_PCR = 1.2  # Above this is bearish
+    BULLISH_PCR = 0.7  # Below this is bullish
 
     def __init__(
         self,
@@ -125,10 +125,7 @@ class OptionsAnalyzer:
         overall = self._combine_sentiment(pcr_sentiment, skew_sentiment)
 
         # Max pain distance
-        max_pain_dist = (
-            (float(snapshot.max_pain) - float(current_price))
-            / float(current_price) * 100
-        )
+        max_pain_dist = (float(snapshot.max_pain) - float(current_price)) / float(current_price) * 100
 
         # Expiry pressure (days until expiry)
         expiry_pressure = self._assess_expiry_pressure(snapshot.expiry)
@@ -232,13 +229,15 @@ class OptionsAnalyzer:
             try:
                 snapshot = self.client.get_options_snapshot(symbol, exp)
                 if snapshot:
-                    levels.append({
-                        "expiry": exp,
-                        "max_pain": float(snapshot.max_pain),
-                        "call_oi": float(snapshot.total_call_oi),
-                        "put_oi": float(snapshot.total_put_oi),
-                        "pcr_oi": snapshot.put_call_ratio_oi,
-                    })
+                    levels.append(
+                        {
+                            "expiry": exp,
+                            "max_pain": float(snapshot.max_pain),
+                            "call_oi": float(snapshot.total_call_oi),
+                            "put_oi": float(snapshot.total_put_oi),
+                            "pcr_oi": snapshot.put_call_ratio_oi,
+                        }
+                    )
             except Exception:
                 continue
 
@@ -279,18 +278,20 @@ class OptionsAnalyzer:
             else:
                 interp = "Bearish bet" if random.random() > 0.5 else "Protective put"
 
-            flows.append(OptionsFlow(
-                symbol=symbol,
-                expiry="2025-01-31",
-                strike=Decimal(str(int(strike))),
-                option_type=opt_type,
-                side=random.choice(["buy", "sell"]),
-                size_contracts=size,
-                premium_usd=Decimal(str(int(premium))),
-                iv_at_trade=round(55 + random.uniform(-10, 15), 1),
-                interpretation=interp,
-                timestamp=datetime.now(),
-            ))
+            flows.append(
+                OptionsFlow(
+                    symbol=symbol,
+                    expiry="2025-01-31",
+                    strike=Decimal(str(int(strike))),
+                    option_type=opt_type,
+                    side=random.choice(["buy", "sell"]),
+                    size_contracts=size,
+                    premium_usd=Decimal(str(int(premium))),
+                    iv_at_trade=round(55 + random.uniform(-10, 15), 1),
+                    interpretation=interp,
+                    timestamp=datetime.now(),
+                )
+            )
 
         return sorted(flows, key=lambda x: x.premium_usd, reverse=True)
 
@@ -313,23 +314,23 @@ def demo():
     print(f"\nExpiry: {snap.expiry}")
     print(f"Exchange: {snap.exchange}")
 
-    print(f"\nImplied Volatility:")
+    print("\nImplied Volatility:")
     print(f"   ATM IV: {snap.atm_iv:.1f}%")
     print(f"   Interpretation: {analysis.iv_interpretation.upper()}")
     print(f"   IV Rank: {analysis.iv_percentile:.0f}th percentile")
 
-    print(f"\nPut/Call Analysis:")
+    print("\nPut/Call Analysis:")
     print(f"   PCR (Volume): {snap.put_call_ratio_volume:.2f}")
     print(f"   PCR (OI): {snap.put_call_ratio_oi:.2f}")
     print(f"   Sentiment: {analysis.sentiment_from_pcr.upper()}")
 
-    print(f"\nMax Pain:")
+    print("\nMax Pain:")
     print(f"   Price: ${snap.max_pain:,.0f}")
     print(f"   Distance: {analysis.max_pain_distance_pct:+.1f}% from current")
 
-    print(f"\nOpen Interest:")
-    print(f"   Calls: ${float(snap.total_call_oi)/1e9:.2f}B")
-    print(f"   Puts:  ${float(snap.total_put_oi)/1e9:.2f}B")
+    print("\nOpen Interest:")
+    print(f"   Calls: ${float(snap.total_call_oi) / 1e9:.2f}B")
+    print(f"   Puts:  ${float(snap.total_put_oi) / 1e9:.2f}B")
 
     print(f"\nOverall Sentiment: {analysis.overall_sentiment.upper()}")
     print(f"Expiry Pressure: {analysis.expiry_pressure.upper()}")
@@ -346,8 +347,8 @@ def demo():
         print(
             f"{lvl['expiry']:<12} "
             f"${lvl['max_pain']:>10,.0f} "
-            f"${lvl['call_oi']/1e9:>10.1f}B "
-            f"${lvl['put_oi']/1e9:>10.1f}B "
+            f"${lvl['call_oi'] / 1e9:>10.1f}B "
+            f"${lvl['put_oi'] / 1e9:>10.1f}B "
             f"{lvl['pcr_oi']:>5.2f}"
         )