Maximize Returns with Leveraged Yield Strategies

import requests
import time
import logging
from typing import Optional

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
log = logging.getLogger("looping-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 LoopingAgent:
    """
    Recursive borrowing agent with health factor monitoring.
    Automatically adjusts leverage and unwinds on risk events.
    """

    SAFE_HEALTH   = 2.0
    WATCH_HEALTH  = 1.5
    WARN_HEALTH   = 1.25
    DANGER_HEALTH = 1.15

    def __init__(
        self,
        strategy:        str   = "steth-loop",
        capital_usdc:    float = 5000,
        target_leverage: float = 3.0,
        protocol:        str   = "aave",
    ):
        self.strategy        = strategy
        self.capital_usdc    = capital_usdc
        self.target_leverage = target_leverage
        self.protocol        = protocol
        self.position_id     = None

    def get_rates(self) -> dict:
        """Fetch current rates for our strategy."""
        r = requests.get(f"{BASE}/leverage/rates", headers=HDR, params={
            "strategy": self.strategy,
            "protocol": self.protocol
        })
        return r.json()

    def open_position(self) -> str:
        """Open the leveraged position and return position_id."""
        rates = self.get_rates()
        log.info(f"Opening {self.strategy} at {self.target_leverage}x | "
               f"projected APY={rates['net_apy_at_leverage'][str(self.target_leverage)]:.1f}%")

        r = requests.post(f"{BASE}/leverage/open", headers=HDR, json={
            "strategy":          self.strategy,
            "initial_capital_usdc": self.capital_usdc,
            "target_leverage":   self.target_leverage,
            "protocol":          self.protocol,
            "auto_unwind_enabled": True
        })
        data = r.json()
        self.position_id = data["position_id"]
        log.info(f"Position opened: {self.position_id} | HF={data['health_factor']:.2f} | "
               f"liq_price=${data['liquidation_price']:,.0f}")
        return self.position_id

    def check_health(self) -> dict:
        """Fetch live health factor data."""
        r = requests.get(f"{BASE}/leverage/health", headers=HDR,
                        params={"position_id": self.position_id})
        return r.json()

    def handle_health(self, hf: float):
        """Take action based on current health factor."""
        if hf >= self.SAFE_HEALTH:
            log.info(f"HF={hf:.2f} — SAFE, no action")

        elif hf >= self.WATCH_HEALTH:
            log.warning(f"HF={hf:.2f} — WATCH, monitoring closely")

        elif hf >= self.WARN_HEALTH:
            log.warning(f"HF={hf:.2f} — WARN, unwind 50%")
            requests.post(f"{BASE}/leverage/unwind", headers=HDR, json={
                "position_id":        self.position_id,
                "partial_unwind_pct": 50
            })

        else:
            log.error(f"HF={hf:.2f} — DANGER, emergency full unwind!")
            requests.post(f"{BASE}/leverage/unwind", headers=HDR, json={
                "position_id":        self.position_id,
                "partial_unwind_pct": 100
            })
            self.position_id = None  # position closed

    def run(self, poll_interval: int = 600):
        """Main monitoring loop. Checks health every 10 minutes."""
        self.open_position()
        while True:
            if not self.position_id:
                log.info("Position closed. Waiting 1h before reopening...")
                time.sleep(3600)
                self.open_position()
                continue
            health  = self.check_health()
            hf      = health["health_factor"]
            dist    = health["distance_to_liquidation_pct"]
            log.info(f"HF={hf:.3f} | dist_to_liq={dist:.1f}% | "
                   f"collateral=${health['collateral_value_usd']:,.0f} | "
                   f"debt=${health['debt_value_usd']:,.0f}")
            self.handle_health(hf)
            time.sleep(poll_interval)

if __name__ == "__main__":
    agent = LoopingAgent(
        strategy        = "steth-loop",
        capital_usdc    = 10000,
        target_leverage = 3.0,
        protocol        = "aave"
    )
    agent.run()