Bitcoin Strategies for AI Agents: HODLing, DCA, and Options

"""
Bitcoin DCA Agent — Purple Flea
RSI-weighted dollar-cost averaging for BTC accumulation.
Purchases weekly, increases buy size at RSI < 30 (oversold).
"""
import asyncio
import aiohttp
import json
import logging
from datetime import datetime, timezone, timedelta
from pathlib import Path
from dataclasses import dataclass, asdict
from typing import Optional

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

PURPLE_FLEA_TRADING = "https://purpleflea.com/trading-api"
PURPLE_FLEA_KEY     = "YOUR_API_KEY"
STATE_FILE          = Path("/var/agent/btc_dca_state.json")


@dataclass
class Purchase:
    timestamp: str
    btc_amount: float
    price_usd: float
    usd_spent: float
    rsi: float
    multiplier: float
    tx_id: str


@dataclass
class DCARun:
    total_btc: float = 0.0
    total_usd_spent: float = 0.0
    purchases: list = None
    last_purchase: Optional[str] = None

    def __post_init__(self):
        if self.purchases is None:
            self.purchases = []

    @property
    def avg_cost_basis(self) -> float:
        if self.total_btc == 0:
            return 0
        return self.total_usd_spent / self.total_btc


class BitcoinDCAAgent:
    def __init__(
        self,
        base_weekly_usd: float = 100.0,   # Default: $100/week
        rsi_oversold: float = 30.0,        # RSI below this → boost buy
        rsi_overbought: float = 70.0,      # RSI above this → reduce buy
        max_multiplier: float = 3.0,        # Max 3x base amount at RSI < 20
    ):
        self.base_weekly_usd = base_weekly_usd
        self.rsi_oversold = rsi_oversold
        self.rsi_overbought = rsi_overbought
        self.max_multiplier = max_multiplier
        self.state = self._load_state()
        self.session: Optional[aiohttp.ClientSession] = None

    def _load_state(self) -> DCARun:
        if STATE_FILE.exists():
            data = json.loads(STATE_FILE.read_text())
            state = DCARun(**{k: v for k, v in data.items() if k != "purchases"})
            state.purchases = [Purchase(**p) for p in data.get("purchases", [])]
            return state
        return DCARun()

    def _save_state(self):
        STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
        data = asdict(self.state)
        STATE_FILE.write_text(json.dumps(data, indent=2))

    def _compute_rsi(self, prices: list[float], period: int = 14) -> float:
        """Standard RSI calculation."""
        if len(prices) < period + 1:
            return 50.0  # Neutral if not enough data

        deltas = [prices[i] - prices[i - 1] for i in range(1, len(prices))]
        gains = [d if d > 0 else 0 for d in deltas]
        losses = [abs(d) if d < 0 else 0 for d in deltas]

        avg_gain = sum(gains[-period:]) / period
        avg_loss = sum(losses[-period:]) / period

        if avg_loss == 0:
            return 100.0
        rs = avg_gain / avg_loss
        return 100 - (100 / (1 + rs))

    def _compute_buy_multiplier(self, rsi: float) -> float:
        """
        RSI-based buy multiplier:
        RSI < 20: 3x base amount (extreme oversold)
        RSI 20-30: 2x base amount (oversold)
        RSI 30-70: 1x base amount (neutral)
        RSI > 70: 0.5x base amount (overbought)
        """
        if rsi < 20:
            return self.max_multiplier
        elif rsi < 30:
            return 2.0
        elif rsi > self.rsi_overbought:
            return 0.5
        else:
            return 1.0

    async def _fetch_btc_price_history(self, days: int = 30) -> list[float]:
        """Fetch BTC daily close prices from Purple Flea Trading API."""
        async with self.session.get(
            f"{PURPLE_FLEA_TRADING}/ohlcv",
            params={"symbol": "BTC/USDT", "interval": "1d", "limit": days},
            headers={"X-API-Key": PURPLE_FLEA_KEY},
        ) as resp:
            data = await resp.json()
        return [candle["close"] for candle in data["candles"]]

    async def _execute_btc_purchase(self, usd_amount: float, rsi: float, multiplier: float) -> Purchase:
        """Execute BTC market buy via Purple Flea Trading API."""
        payload = {
            "symbol": "BTC/USDT",
            "side": "buy",
            "type": "market",
            "quote_amount": usd_amount,  # Buy $X worth of BTC
        }
        async with self.session.post(
            f"{PURPLE_FLEA_TRADING}/order", json=payload,
            headers={"X-API-Key": PURPLE_FLEA_KEY},
        ) as resp:
            result = await resp.json()

        purchase = Purchase(
            timestamp=datetime.now(timezone.utc).isoformat(),
            btc_amount=result["base_amount"],
            price_usd=result["avg_price"],
            usd_spent=usd_amount,
            rsi=rsi,
            multiplier=multiplier,
            tx_id=result["order_id"],
        )
        return purchase

    def _should_buy_this_week(self) -> bool:
        """Check if 7 days have passed since last purchase."""
        if self.state.last_purchase is None:
            return True
        last = datetime.fromisoformat(self.state.last_purchase)
        return datetime.now(timezone.utc) - last >= timedelta(days=7)

    async def run_once(self):
        """Check and potentially execute a DCA purchase."""
        if not self._should_buy_this_week():
            log.info("Not yet time for this week's purchase.")
            return

        prices = await self._fetch_btc_price_history(30)
        current_price = prices[-1]
        rsi = self._compute_rsi(prices)
        multiplier = self._compute_buy_multiplier(rsi)
        buy_amount = self.base_weekly_usd * multiplier

        log.info(
            f"BTC @ ${current_price:,.0f} | RSI: {rsi:.1f} | "
            f"Multiplier: {multiplier}x | Buying: ${buy_amount:.2f}"
        )

        purchase = await self._execute_btc_purchase(buy_amount, rsi, multiplier)

        self.state.total_btc += purchase.btc_amount
        self.state.total_usd_spent += purchase.usd_spent
        self.state.last_purchase = purchase.timestamp
        self.state.purchases.append(purchase)
        self._save_state()

        log.info(
            f"Purchased {purchase.btc_amount:.6f} BTC | "
            f"Total: {self.state.total_btc:.6f} BTC | "
            f"Avg cost: ${self.state.avg_cost_basis:,.0f}"
        )

    async def run_loop(self):
        """Check daily for weekly purchase opportunities."""
        self.session = aiohttp.ClientSession()
        try:
            while True:
                await self.run_once()
                await asyncio.sleep(86400)  # Check once per day
        finally:
            await self.session.close()


if __name__ == "__main__":
    agent = BitcoinDCAAgent(
        base_weekly_usd=100.0,
        rsi_oversold=30.0,
        rsi_overbought=70.0,
        max_multiplier=3.0,
    )
    asyncio.run(agent.run_loop())

"""Generate portfolio report for BTC DCA agent."""
import json
from pathlib import Path

def report(state_path: str, current_btc_price: float):
    data = json.loads(Path(state_path).read_text())
    total_btc   = data["total_btc"]
    total_spent = data["total_usd_spent"]
    avg_cost    = total_spent / total_btc if total_btc > 0 else 0
    current_val = total_btc * current_btc_price
    unrealized  = current_val - total_spent
    roi_pct     = (unrealized / total_spent * 100) if total_spent > 0 else 0

    print(f"=== BTC DCA Portfolio Report ===")
    print(f"Total BTC:       {total_btc:.6f} BTC")
    print(f"Total Invested:  ${total_spent:,.2f}")
    print(f"Avg Cost Basis:  ${avg_cost:,.2f}/BTC")
    print(f"Current Price:   ${current_btc_price:,.2f}/BTC")
    print(f"Portfolio Value: ${current_val:,.2f}")
    print(f"Unrealized P&L:  ${unrealized:,.2f} ({roi_pct:+.1f}%)")
    print(f"Purchases:       {len(data['purchases'])}")

    # RSI distribution of purchases
    purchases = data["purchases"]
    oversold_buys = [p for p in purchases if p["rsi"] < 30]
    print(f"Oversold Buys:   {len(oversold_buys)} ({len(oversold_buys)/len(purchases)*100:.0f}% of buys)")


report("/var/agent/btc_dca_state.json", current_btc_price=42_500)
# === BTC DCA Portfolio Report ===
# Total BTC:       0.312847 BTC
# Total Invested:  $10,400.00
# Avg Cost Basis:  $33,244/BTC
# Current Price:   $42,500/BTC
# Portfolio Value: $13,295.99
# Unrealized P&L:  $2,895.99 (+27.8%)
# Purchases:       52
# Oversold Buys:   12 (23% of buys)