Automate Options Vault Strategies

import requests
import time
from datetime import datetime, timezone
from typing import Optional

# Purple Flea Options Vault Agent
# Deposits into highest-Sharpe vault automatically

BASE_URL = "https://purpleflea.com/api/v1"
API_KEY  = "pf_live_your_key_here"
HEADERS  = {"X-API-Key": API_KEY, "Content-Type": "application/json"}

class OptionsVaultAgent:
    def __init__(self, total_usdc: float, min_sharpe: float = 1.5):
        self.total_usdc  = total_usdc
        self.min_sharpe  = min_sharpe
        self.positions   = {}

    def get_vaults(self) -> list:
        """Fetch all active vaults sorted by Sharpe ratio."""
        r = requests.get(
            f"{BASE_URL}/vaults",
            headers=HEADERS,
            params={"status": "active", "sort": "sharpe_desc"}
        )
        r.raise_for_status()
        return r.json()["vaults"]

    def get_strikes(self, vault_id: str) -> dict:
        """Get current epoch strike data and IV rank."""
        r = requests.get(
            f"{BASE_URL}/vaults/strikes",
            headers=HEADERS,
            params={"vault_id": vault_id}
        )
        return r.json()

    def select_best_vault(self, vaults: list) -> Optional[dict]:
        """Pick the vault with highest Sharpe above our minimum threshold."""
        candidates = [
            v for v in vaults
            if v["sharpe_90d"] >= self.min_sharpe
            and v["deposit_capacity_usdc"] >= self.total_usdc
            and v["days_to_next_epoch"] >= 1
        ]
        if not candidates:
            return None
        return max(candidates, key=lambda v: v["sharpe_90d"])

    def deposit(self, vault_id: str, amount_usdc: float) -> dict:
        """Deposit USDC into the target vault."""
        r = requests.post(
            f"{BASE_URL}/vaults/deposit",
            headers=HEADERS,
            json={
                "vault_id":    vault_id,
                "amount_usdc": amount_usdc,
                "roll_mode":   "neutral"
            }
        )
        r.raise_for_status()
        return r.json()

    def check_iv_and_adjust(self, strike_data: dict) -> str:
        """Adjust roll mode based on current IV rank."""
        iv_rank = strike_data.get("iv_rank", 50)
        if iv_rank >= 60:
            return "aggressive"   # IV rich → sell more premium
        elif iv_rank <= 25:
            return "conservative" # IV crushed → protect capital
        return "neutral"

    def run_epoch(self):
        """Execute one vault selection and deposit cycle."""
        print(f"[{datetime.now(timezone.utc).isoformat()}] Scanning vaults...")

        vaults = self.get_vaults()
        print(f"Found {len(vaults)} active vaults")

        best = self.select_best_vault(vaults)
        if not best:
            print("No qualifying vault found. Holding USDC.")
            return

        print(f"Selected: {best['name']} | Sharpe={best['sharpe_90d']:.2f} | APY={best['apy_90d']:.1f}%")

        strike_data = self.get_strikes(best["id"])
        roll_mode   = self.check_iv_and_adjust(strike_data)
        print(f"IV rank={strike_data.get('iv_rank')} → roll_mode={roll_mode}")

        result = self.deposit(best["id"], self.total_usdc)
        print(f"Deposited {self.total_usdc} USDC → receipt={result['receipt_id']}")
        print(f"Next epoch: {result['epoch_start']} → {result['epoch_end']}")
        print(f"Projected premium: {result['projected_premium_usdc']:.2f} USDC")

# Run the agent
if __name__ == "__main__":
    agent = OptionsVaultAgent(total_usdc=10000, min_sharpe=1.5)
    agent.run_epoch()