Run an Autonomous Crypto Index Fund

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

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("index-fund-agent")

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

class IndexFundAgent:
    """
    Manages a crypto index fund autonomously.
    Monthly rebalancing + drift monitoring + tax-loss harvesting.
    """

    def __init__(
        self,
        index_id:         str   = "large-cap-10",
        weight_method:    str   = "market_cap",
        rebalance_mode:   str   = "smart",
        drift_threshold:  float = 5.0,     # % drift to trigger early rebalance
        tax_harvest:      bool  = True,
    ):
        self.index_id        = index_id
        self.weight_method   = weight_method
        self.rebalance_mode  = rebalance_mode
        self.drift_threshold = drift_threshold
        self.tax_harvest     = tax_harvest
        self.last_rebalance  = None
        self.rebalance_count = 0

    def get_target_weights(self) -> dict:
        """Fetch current target weights from the API."""
        r = requests.get(f"{BASE}/index/weights", headers=HDR, params={
            "index_id":      self.index_id,
            "weight_method": self.weight_method
        })
        return r.json()

    def check_drift(self) -> dict:
        """Get current drift from target weights."""
        r = requests.get(f"{BASE}/index/drift", headers=HDR, params={
            "index_id":        self.index_id,
            "alert_threshold": self.drift_threshold
        })
        return r.json()

    def should_rebalance(self, drift_data: dict) -> tuple[bool, str]:
        """Determine if rebalance is needed and why."""
        now = datetime.now(timezone.utc)

        # Monthly calendar trigger
        if self.last_rebalance is None:
            return True, "initial"
        if (now - self.last_rebalance).days >= 30:
            return True, "calendar_monthly"

        # Drift threshold trigger
        max_drift = max(
            abs(asset["drift_pct"])
            for asset in drift_data["assets"]
        )
        if max_drift >= self.drift_threshold:
            return True, f"drift_{max_drift:.1f}pct"

        return False, "no_action"

    def run_tax_harvest(self):
        """Check for and execute tax-loss harvesting opportunities."""
        r = requests.get(f"{BASE}/index/tax-harvest", headers=HDR)
        data = r.json()
        if not data["harvest_candidates"]:
            log.info("No tax-loss harvest opportunities found")
            return
        for candidate in data["harvest_candidates"]:
            log.info(
                f"Harvest: sell {candidate['asset']} (loss=${candidate['unrealized_loss_usd']:.2f}) "
                f"→ buy {candidate['substitute']} (correlation={candidate['correlation']:.2f})"
            )
            # Execute harvest via rebalance with harvest flag
            requests.post(f"{BASE}/index/rebalance", headers=HDR, json={
                "index_id":      self.index_id,
                "harvest_asset": candidate["asset"],
                "substitute":    candidate["substitute"],
                "dry_run":       False
            })

    def rebalance(self, reason: str):
        """Execute a full portfolio rebalance."""
        log.info(f"Starting rebalance #{self.rebalance_count+1} | reason={reason}")

        # Preview first
        preview = requests.post(f"{BASE}/index/rebalance", headers=HDR, json={
            "index_id":      self.index_id,
            "weight_method": self.weight_method,
            "dry_run":       True
        }).json()
        total_cost = preview["estimated_cost_usd"]
        trades     = len(preview["trades"])
        log.info(f"Preview: {trades} trades | est cost=${total_cost:.2f}")

        # Execute if cost is reasonable (<0.3% of portfolio)
        if total_cost / preview["portfolio_value_usd"] < 0.003:
            result = requests.post(f"{BASE}/index/rebalance", headers=HDR, json={
                "index_id":      self.index_id,
                "weight_method": self.weight_method,
                "dry_run":       False
            }).json()
            self.last_rebalance  = datetime.now(timezone.utc)
            self.rebalance_count += 1
            log.info(f"Rebalance complete | tx_hash={result['tx_hash']}")
        else:
            log.warning(f"Rebalance cost too high (${total_cost:.2f}), skipping")

    def log_performance(self):
        """Log current index performance."""
        r = requests.get(f"{BASE}/index/performance", headers=HDR, params={
            "index_id": self.index_id, "period": "30d"
        })
        p = r.json()
        log.info(
            f"30d performance: {p['return_pct']:+.1f}% | "
            f"Sharpe={p['sharpe']:.2f} | MaxDD={p['max_drawdown_pct']:.1f}%"
        )

    def run(self, check_interval_sec: int = 86400):
        """Daily check: drift monitor, monthly rebalance, tax harvest."""
        log.info(f"IndexFundAgent starting | index={self.index_id} | method={self.weight_method}")
        while True:
            try:
                drift                   = self.check_drift()
                needs_rebalance, reason = self.should_rebalance(drift)
                if needs_rebalance:
                    self.rebalance(reason)
                if self.tax_harvest:
                    self.run_tax_harvest()
                self.log_performance()
            except Exception as e:
                log.error(f"Error in main loop: {e}")
            time.sleep(check_interval_sec)

if __name__ == "__main__":
    agent = IndexFundAgent(
        index_id       = "large-cap-10",
        weight_method  = "market_cap",
        rebalance_mode = "smart",
        drift_threshold= 5.0,
        tax_harvest    = True
    )
    agent.run()