AI Agent Crypto Options & Derivatives Strategies: Greeks, Volatility, and Systematic Execution

import requests, json
from dataclasses import dataclass, field
from typing import List, Dict
import math

DERIBIT_BASE = "https://www.deribit.com/api/v2"

@dataclass
class OptionPosition:
    instrument: str           # e.g. "BTC-28MAR25-80000-C"
    size: float               # positive = long, negative = short
    delta: float
    gamma: float
    theta: float
    vega: float
    mark_price: float
    underlying_price: float

@dataclass
class PortfolioGreeks:
    net_delta: float = 0.0
    net_gamma: float = 0.0
    net_theta: float = 0.0     # daily USD theta
    net_vega: float  = 0.0     # per 1-vol-point
    positions: List[OptionPosition] = field(default_factory=list)

def fetch_option_greeks(instrument_name: str) -> dict:
    """Fetch mark price + greeks for a single option from Deribit."""
    resp = requests.get(
        f"{DERIBIT_BASE}/public/get_order_book",
        params={"instrument_name": instrument_name, "depth": 1}
    )
    data = resp.json()["result"]
    greeks = data.get("greeks", {})
    return {
        "delta":       greeks.get("delta",  0.0),
        "gamma":       greeks.get("gamma",  0.0),
        "theta":       greeks.get("theta",  0.0),
        "vega":        greeks.get("vega",   0.0),
        "mark_price":  data.get("mark_price", 0.0),
        "underlying":  data.get("underlying_price", 0.0),
        "iv":          data.get("mark_iv", 0.0),
    }

def build_portfolio_greeks(positions_raw: List[Dict]) -> PortfolioGreeks:
    """
    positions_raw: [{"instrument": "BTC-28MAR25-80000-C", "size": -1.0}, ...]
    Returns aggregated portfolio Greeks.
    """
    portfolio = PortfolioGreeks()
    for p in positions_raw:
        g = fetch_option_greeks(p["instrument"])
        pos = OptionPosition(
            instrument      = p["instrument"],
            size            = p["size"],
            delta           = g["delta"],
            gamma           = g["gamma"],
            theta           = g["theta"],
            vega            = g["vega"],
            mark_price      = g["mark_price"],
            underlying_price= g["underlying"],
        )
        portfolio.positions.append(pos)
        portfolio.net_delta += pos.delta * pos.size
        portfolio.net_gamma += pos.gamma * pos.size
        portfolio.net_theta += pos.theta * pos.size  # theta is per-day USD
        portfolio.net_vega  += pos.vega  * pos.size
    return portfolio

# Example usage
positions = [
    {"instrument": "BTC-28MAR25-80000-C", "size": -2.0},  # short 2 calls
    {"instrument": "BTC-28MAR25-75000-P", "size": -2.0},  # short 2 puts
]
book = build_portfolio_greeks(positions)
print(f"Net Delta: {book.net_delta:.4f} BTC")
print(f"Net Gamma: {book.net_gamma:.6f} per $1 move")
print(f"Net Theta: ${book.net_theta:.2f} / day")
print(f"Net Vega:  ${book.net_vega:.2f} per 1-vol-pt")

import requests, time
from datetime import datetime, timedelta

DERIBIT = "https://www.deribit.com/api/v2"
DERIBIT_KEY = "your_deribit_api_key"
DERIBIT_SECRET = "your_deribit_secret"

def get_btc_instruments():
    """Fetch all live BTC options instruments."""
    resp = requests.get(f"{DERIBIT}/public/get_instruments",
        params={"currency": "BTC", "kind": "option", "expired": "false"})
    return resp.json()["result"]

def get_spot_price():
    resp = requests.get(f"{DERIBIT}/public/get_index_price",
        params={"index_name": "btc_usd"})
    return resp.json()["result"]["index_price"]

def find_covered_call_strike(instruments, spot_price,
                               target_delta=0.25, days_out=7):
    """
    Find the call closest to target_delta with ~days_out days to expiry.
    Returns the best instrument or None.
    """
    target_expiry = datetime.utcnow() + timedelta(days=days_out)
    candidates = []
    for inst in instruments:
        if inst["option_type"] != "call":
            continue
        exp_ts = inst["expiration_timestamp"] / 1000
        exp_dt = datetime.utcfromtimestamp(exp_ts)
        days_to_exp = (exp_dt - datetime.utcnow()).days
        if not (5 <= days_to_exp <= 14):
            continue
        book = requests.get(f"{DERIBIT}/public/get_order_book",
            params={"instrument_name": inst["instrument_name"], "depth": 1}).json()["result"]
        greeks = book.get("greeks", {})
        delta = greeks.get("delta", 1.0)
        bid = book.get("best_bid_price", 0)
        iv  = book.get("mark_iv", 0)
        if bid < 0.001:  # skip illiquid strikes
            continue
        candidates.append({
            "instrument": inst["instrument_name"],
            "delta":      delta,
            "bid":        bid,
            "iv":         iv,
            "days":       days_to_exp,
            "strike":     inst["strike"],
            "delta_dist": abs(delta - target_delta),
        })
    if not candidates:
        return None
    candidates.sort(key=lambda x: x["delta_dist"])
    return candidates[0]

# --- Main covered call loop ---
spot = get_spot_price()
instruments = get_btc_instruments()
best_call = find_covered_call_strike(instruments, spot)

if best_call:
    annual_yield = (best_call["bid"] * spot) / spot * (365 / best_call["days"]) * 100
    print(f"Best covered call: {best_call['instrument']}")
    print(f"  Delta:     {best_call['delta']:.3f}")
    print(f"  Bid (BTC): {best_call['bid']:.4f}")
    print(f"  IV:        {best_call['iv']:.1f}%")
    print(f"  Annualized yield: ~{annual_yield:.1f}%")

const axios = require('axios');

const DERIBIT = 'https://www.deribit.com/api/v2';

async function findAtmStraddle(currency = 'BTC', targetDays = 7) {
  // Step 1: Get spot price
  const indexResp = await axios.get(`${DERIBIT}/public/get_index_price`,
    { params: { index_name: `${currency.toLowerCase()}_usd` } });
  const spot = indexResp.data.result.index_price;

  // Step 2: Get all options
  const instResp = await axios.get(`${DERIBIT}/public/get_instruments`,
    { params: { currency, kind: 'option', expired: 'false' } });
  const instruments = instResp.data.result;

  // Step 3: Filter to target expiry window
  const now = Date.now();
  const targetMs = targetDays * 86400000;
  const nearExpiry = instruments.filter(i => {
    const msToExp = i.expiration_timestamp - now;
    return msToExp > 3 * 86400000 && msToExp < 14 * 86400000;
  });

  // Step 4: Find ATM strike (closest to spot)
  const strikes = [...new Set(nearExpiry.map(i => i.strike))].sort((a,b) => a-b);
  const atmStrike = strikes.reduce((prev, curr) =>
    Math.abs(curr - spot) < Math.abs(prev - spot) ? curr : prev);

  // Step 5: Fetch call and put books at ATM strike
  const callName = nearExpiry.find(i => i.strike === atmStrike && i.option_type === 'call')?.instrument_name;
  const putName  = nearExpiry.find(i => i.strike === atmStrike && i.option_type === 'put')?.instrument_name;

  const [callBook, putBook] = await Promise.all([
    axios.get(`${DERIBIT}/public/get_order_book`, { params: { instrument_name: callName, depth: 1 } }),
    axios.get(`${DERIBIT}/public/get_order_book`, { params: { instrument_name: putName,  depth: 1 } }),
  ]);
  const callAsk = callBook.data.result.best_ask_price;
  const putAsk  = putBook.data.result.best_ask_price;
  const callIV  = callBook.data.result.mark_iv;
  const putIV   = putBook.data.result.mark_iv;
  const straddelCost = (callAsk + putAsk) * spot;  // in USD
  const avgIV   = (callIV + putIV) / 2;

  // Breakeven: spot must move +/- straddle_cost / spot from strike
  const breakevenPct = ((callAsk + putAsk) / 2) * 100;

  console.log(`ATM Straddle Analysis: ${callName} + ${putName}`);
  console.log(`  Spot:           $${spot.toLocaleString()}`);
  console.log(`  ATM Strike:     $${atmStrike.toLocaleString()}`);
  console.log(`  Call ask (BTC): ${callAsk.toFixed(4)}`);
  console.log(`  Put ask (BTC):  ${putAsk.toFixed(4)}`);
  console.log(`  Total cost:     $${straddelCost.toFixed(0)}`);
  console.log(`  Avg IV:         ${avgIV.toFixed(1)}%`);
  console.log(`  Breakeven move: ±${breakevenPct.toFixed(2)}%`);
  return { callName, putName, cost: straddelCost, iv: avgIV, breakevenPct };
}

findAtmStraddle('BTC', 7).catch(console.error);

import requests

PF_BASE    = "https://purpleflea.com/api/v1"
PF_API_KEY = "your_pf_api_key"

def get_pf_perp_position(symbol="BTC-USDC"):
    """Fetch current PF perpetual position for BTC."""
    resp = requests.get(f"{PF_BASE}/trading/positions",
        headers={"Authorization": f"Bearer {PF_API_KEY}"})
    positions = resp.json().get("positions", [])
    for p in positions:
        if p["symbol"] == symbol:
            return p["size"]   # negative = short, positive = long
    return 0.0

def place_pf_perp_order(symbol, side, size, order_type="market"):
    """Place a perp order on Purple Flea to adjust delta hedge."""
    payload = {
        "symbol":     symbol,
        "side":       side,       # "buy" or "sell"
        "size":       size,
        "type":       order_type,
    }
    resp = requests.post(f"{PF_BASE}/trading/order",
        headers={"Authorization": f"Bearer {PF_API_KEY}"},
        json=payload)
    return resp.json()

def rebalance_delta(options_net_delta: float,
                    hedge_threshold: float = 0.05):
    """
    options_net_delta: the options book's net delta in BTC.
    A positive net_delta means the book is net long delta — we need
    to short perps to bring the total portfolio delta to zero.
    hedge_threshold: minimum |delta| before placing a hedge trade.
    """
    current_perp_pos = get_pf_perp_position("BTC-USDC")
    # total portfolio delta = options_delta + perp_position
    total_delta = options_net_delta + current_perp_pos

    if abs(total_delta) < hedge_threshold:
        print(f"Delta within threshold ({total_delta:.4f} BTC). No trade.")
        return None

    # required adjustment: -total_delta on perps
    adj_size = abs(total_delta)
    adj_side = "sell" if total_delta > 0 else "buy"
    print(f"Rebalancing: {adj_side} {adj_size:.4f} BTC perp on PF")
    result = place_pf_perp_order("BTC-USDC", adj_side, adj_size)
    print(f"Order result: {result}")
    return result

# Example: options book has net delta of +0.30 BTC
# Agent will sell 0.30 BTC perp on Purple Flea to delta-neutral
rebalance_delta(options_net_delta=0.30, hedge_threshold=0.05)

import requests, json
from collections import defaultdict

def build_iv_surface(currency="BTC"):
    """
    Build a simplified IV surface: {expiry_date: {strike: iv}}
    Returns a nested dict and a summary of ATM IVs per expiry.
    """
    DERIBIT = "https://www.deribit.com/api/v2"
    spot_resp = requests.get(f"{DERIBIT}/public/get_index_price",
        params={"index_name": f"{currency.lower()}_usd"})
    spot = spot_resp.json()["result"]["index_price"]

    inst_resp = requests.get(f"{DERIBIT}/public/get_instruments",
        params={"currency": currency, "kind": "option", "expired": "false"})
    instruments = inst_resp.json()["result"]

    surface = defaultdict(dict)   # surface[expiry][strike] = iv
    atm_ivs = {}                  # atm_ivs[expiry] = atm_iv

    # Batch fetch using get_book_summary_by_currency
    summary_resp = requests.get(f"{DERIBIT}/public/get_book_summary_by_currency",
        params={"currency": currency, "kind": "option"})
    summaries = summary_resp.json()["result"]

    inst_map = {i["instrument_name"]: i for i in instruments}

    for s in summaries:
        name = s.get("instrument_name", "")
        iv   = s.get("mark_iv", 0.0)
        if iv == 0.0 or name not in inst_map:
            continue
        inst = inst_map[name]
        strike  = inst["strike"]
        expiry  = name.split("-")[1]   # e.g. "28MAR25"
        surface[expiry][strike] = iv

    # Compute ATM IV per expiry (closest strike to spot)
    for expiry, strike_ivs in surface.items():
        atm = min(strike_ivs.keys(), key=lambda k: abs(k - spot))
        atm_ivs[expiry] = strike_ivs[atm]

    # Print term structure
    print("=== IV Term Structure (ATM) ===")
    for exp in sorted(atm_ivs.keys()):
        print(f"  {exp:10s}  ATM IV: {atm_ivs[exp]:.1f}%")

    return surface, atm_ivs

surface, atm_ivs = build_iv_surface("BTC")

def find_calendar_opportunities(surface, atm_ivs,
                                  spread_threshold=8.0):
    """
    Finds expiry pairs where front-month ATM IV is significantly
    higher than back-month ATM IV (long calendar opportunity).
    spread_threshold: minimum front-back IV spread in vol points.
    """
    expiries = sorted(atm_ivs.keys())
    opportunities = []

    for i in range(len(expiries) - 1):
        front = expiries[i]
        back  = expiries[i + 1]
        iv_front = atm_ivs[front]
        iv_back  = atm_ivs[back]
        spread   = iv_front - iv_back

        if spread >= spread_threshold:
            opportunities.append({
                "front_expiry": front,
                "back_expiry":  back,
                "iv_front":     iv_front,
                "iv_back":      iv_back,
                "spread_pts":   spread,
                "type":         "long_calendar",
            })

    opportunities.sort(key=lambda x: -x["spread_pts"])
    for opp in opportunities[:3]:
        print(f"Calendar: sell {opp['front_expiry']} ({opp['iv_front']:.1f}%) / "
              f"buy {opp['back_expiry']} ({opp['iv_back']:.1f}%) — spread {opp['spread_pts']:.1f} vol pts")
    return opportunities

find_calendar_opportunities(surface, atm_ivs, spread_threshold=6.0)

const axios = require('axios');

async function getDvol(currency = 'BTC') {
  const resp = await axios.get('https://www.deribit.com/api/v2/public/get_volatility_index_data', {
    params: {
      currency,
      start_timestamp: Date.now() - 300000,  // last 5 minutes
      end_timestamp:   Date.now(),
      resolution:      '60',               // 1-minute candles
    }
  });
  const candles = resp.data.result.data;
  if (!candles.length) return null;
  const latest = candles[candles.length - 1];
  return latest[4]; // close value
}

function getStrategyMode(dvol) {
  if (dvol < 40)  return { mode: 'long_vol',    action: 'Buy straddles / long calendars' };
  if (dvol < 55)  return { mode: 'theta_farm',  action: 'Covered calls + cash-secured puts' };
  if (dvol < 75)  return { mode: 'condor',      action: 'Iron condors + wide strangles' };
  if (dvol < 100) return { mode: 'reduce_short', action: 'Close short vol; switch to delta hedge' };
  return           { mode: 'crisis',       action: 'Long vol only; no naked short options' };
}

async function main() {
  const dvol = await getDvol('BTC');
  const strategy = getStrategyMode(dvol);
  console.log(`BTC DVOL: ${dvol.toFixed(1)}`);
  console.log(`Mode:     ${strategy.mode}`);
  console.log(`Action:   ${strategy.action}`);
  // An agent would pass strategy.mode to its position-sizing and
  // entry-criteria modules to adjust behavior accordingly.
}

main();

import requests, time, logging
from datetime import datetime, timezone

logging.basicConfig(level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("covered_call_agent")

DERIBIT    = "https://www.deribit.com/api/v2"
PF_BASE    = "https://purpleflea.com/api/v1"
PF_HEADERS = {"Authorization": "Bearer your_pf_api_key"}

BTC_SPOT_HOLDINGS = 1.0    # agent holds 1 BTC spot
TARGET_DELTA      = 0.25  # sell 25-delta calls
ROLL_TRIGGER      = 0.45  # roll if short call delta exceeds 0.45

def check_existing_short_calls():
    """Return list of active short call positions on Deribit."""
    # (requires Deribit auth — omitted for brevity)
    return []

def should_roll(position):
    g = fetch_option_greeks(position["instrument"])
    return g["delta"] > ROLL_TRIGGER

def run_covered_call_cycle():
    log.info("--- Covered call cycle starting ---")
    spot = get_spot_price()
    log.info(f"BTC spot: ${spot:,.0f}")

    existing = check_existing_short_calls()
    if existing:
        for pos in existing:
            if should_roll(pos):
                log.warning(f"Rolling {pos['instrument']} — delta too high")
                # close existing + open new further-dated call
                # (Deribit order placement omitted — requires auth)
        log.info("Existing short calls checked; no new position needed.")
        return

    # No existing position — find and sell a new call
    instruments = get_btc_instruments()
    best_call   = find_covered_call_strike(instruments, spot,
                    target_delta=TARGET_DELTA, days_out=7)
    if not best_call:
        log.warning("No suitable call found this cycle.")
        return

    ann_yield = best_call["bid"] * (365 / best_call["days"]) * 100
    log.info(f"Selling {best_call['instrument']} | delta={best_call['delta']:.3f} | "
            f"IV={best_call['iv']:.1f}% | annualized={ann_yield:.1f}%")

    # Submit sell order on Deribit (auth + order placement omitted)
    # After sell, rebalance delta on Purple Flea perp
    options_delta = -BTC_SPOT_HOLDINGS * best_call["delta"]
    rebalance_delta(options_net_delta=options_delta)
    log.info("Cycle complete.")

# Run every 4 hours
while True:
    try:
        run_covered_call_cycle()
    except Exception as e:
        log.error(f"Cycle error: {e}")
    time.sleep(4 * 3600)

const axios = require('axios');

// Cumulative standard normal distribution (Abramowitz & Stegun approximation)
function normCdf(x) {
  const a1 = 0.254829592, a2 = -0.284496736, a3 = 1.421413741;
  const a4 = -1.453152027, a5 = 1.061405429, p = 0.3275911;
  const sign = x < 0 ? -1 : 1;
  x = Math.abs(x);
  const t = 1.0 / (1.0 + p * x);
  const y = 1.0 - (((((a5*t + a4)*t + a3)*t + a2)*t + a1)*t * Math.exp(-x*x));
  return 0.5 * (1.0 + sign * y);
}

function bsGreeks(S, K, T, r, sigma, type = 'call') {
  // S=spot, K=strike, T=years to expiry, r=rate, sigma=IV decimal
  const d1 = (Math.log(S/K) + (r + sigma*sigma/2)*T) / (sigma * Math.sqrt(T));
  const d2 = d1 - sigma * Math.sqrt(T);
  const nd1 = normCdf(d1);
  const phi = Math.exp(-d1*d1/2) / Math.sqrt(2 * Math.PI);
  const delta = type === 'call' ? nd1 : nd1 - 1;
  const gamma = phi / (S * sigma * Math.sqrt(T));
  const theta = (-(S * phi * sigma) / (2 * Math.sqrt(T))
               - r * K * Math.exp(-r*T) * normCdf(type === 'call' ? d2 : -d2)) / 365;
  const vega  = S * phi * Math.sqrt(T) / 100;  // per 1-vol-point
  return { delta, gamma, theta, vega };
}

async function fetchAndAnalyzeChain(currency = 'BTC', targetExpiry = null) {
  const DERIBIT = 'https://www.deribit.com/api/v2';

  const [idxResp, sumResp] = await Promise.all([
    axios.get(`${DERIBIT}/public/get_index_price`,
      { params: { index_name: `${currency.toLowerCase()}_usd` } }),
    axios.get(`${DERIBIT}/public/get_book_summary_by_currency`,
      { params: { currency, kind: 'option' } }),
  ]);

  const spot = idxResp.data.result.index_price;
  const chain = sumResp.data.result;
  const r = 0.05;  // risk-free rate estimate

  const results = chain
    .filter(o => !targetExpiry || o.instrument_name.includes(targetExpiry))
    .filter(o => o.mark_iv > 0 && o.open_interest > 0)
    .map(o => {
      const parts  = o.instrument_name.split('-');
      const strike = parseFloat(parts[2]);
      const type   = parts[3] === 'C' ? 'call' : 'put';
      const T      = (o.creation_timestamp
        ? Math.max(0.001, (o.expiration_timestamp - Date.now()) / (365 * 86400000))
        : 7/365);
      const sigma  = o.mark_iv / 100;
      const g      = bsGreeks(spot, strike, T, r, sigma, type);
      return {
        instrument: o.instrument_name,
        type, strike, T: (T * 365).toFixed(1),
        iv: o.mark_iv.toFixed(1), bid: o.best_bid_price, ask: o.best_ask_price,
        delta:  g.delta.toFixed(4),
        gamma:  g.gamma.toFixed(6),
        theta:  g.theta.toFixed(4),
        vega:   g.vega.toFixed(4),
        oi: o.open_interest,
      };
    });

  // Print top 10 by open interest
  results.sort((a, b) => b.oi - a.oi).slice(0, 10).forEach(r =>
    console.log(JSON.stringify(r, null, 2))
  );
  return results;
}

fetchAndAnalyzeChain('BTC').catch(console.error);

from dataclasses import dataclass
from typing import List

@dataclass
class RiskLimits:
    max_abs_delta:  float = 0.10    # BTC
    min_gamma:      float = -0.005  # BTC per $1
    min_theta_daily:float = -50.0  # USD per day
    max_abs_vega:   float = 300.0   # USD per 1 vol point

def check_risk_limits(portfolio: PortfolioGreeks,
                      limits: RiskLimits) -> List[str]:
    """Returns a list of breach messages. Empty = within limits."""
    breaches = []

    if abs(portfolio.net_delta) > limits.max_abs_delta:
        breaches.append(
            f"DELTA BREACH: {portfolio.net_delta:.4f} BTC (limit ±{limits.max_abs_delta})")

    if portfolio.net_gamma < limits.min_gamma:
        breaches.append(
            f"GAMMA BREACH: {portfolio.net_gamma:.6f} (limit {limits.min_gamma})")

    if portfolio.net_theta < limits.min_theta_daily:
        breaches.append(
            f"THETA BREACH: ${portfolio.net_theta:.2f}/day (limit ${limits.min_theta_daily})")

    if abs(portfolio.net_vega) > limits.max_abs_vega:
        breaches.append(
            f"VEGA BREACH: ${portfolio.net_vega:.2f}/vol-pt (limit ±${limits.max_abs_vega})")

    return breaches

def risk_monitor_loop(positions_raw, limits=None):
    if limits is None:
        limits = RiskLimits()
    portfolio = build_portfolio_greeks(positions_raw)
    breaches  = check_risk_limits(portfolio, limits)

    if breaches:
        for b in breaches:
            print(f"[RISK ALERT] {b}")
        # Trigger automatic delta rebalance if delta breached
        if any("DELTA" in b for b in breaches):
            rebalance_delta(portfolio.net_delta, hedge_threshold=0.02)
    else:
        print(f"[RISK OK] delta={portfolio.net_delta:.4f} gamma={portfolio.net_gamma:.6f} "
              f"theta=${portfolio.net_theta:.2f}/day vega=${portfolio.net_vega:.2f}/vol-pt")

    return portfolio, breaches