DeFi Lending API for AI Agents

import requests
import time

BASE_URL = "https://purpleflea.com/api/v1/defi"

class LendingAgent:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        }

    # ─── Supply ──────────────────────────────────────────────

    def supply_usdc(self, amount_usdc: float, protocol: str = "aave-v3", chain: str = "ethereum"):
        """Supply USDC to earn variable APY."""
        resp = requests.post(
            f"{BASE_URL}/supply",
            headers=self.headers,
            json={
                "protocol": protocol,
                "chain": chain,
                "asset": "USDC",
                "amount": amount_usdc,
            }
        )
        data = resp.json()
        print(f"Supplied {amount_usdc} USDC to {protocol} on {chain}")
        print(f"aToken balance: {data['atoken_balance']} aUSDC")
        print(f"Current supply APY: {data['supply_apy']*100:.2f}%")
        return data

    # ─── Borrow ──────────────────────────────────────────────

    def borrow_against_eth(self, eth_collateral: float, usdc_to_borrow: float):
        """
        Supply ETH collateral, then borrow USDC.
        ETH max LTV on Aave V3 Ethereum: 80%.
        """
        # Step 1: supply ETH as collateral
        requests.post(
            f"{BASE_URL}/supply",
            headers=self.headers,
            json={"protocol": "aave-v3", "chain": "ethereum", "asset": "WETH", "amount": eth_collateral}
        )

        # Step 2: borrow USDC against that collateral
        resp = requests.post(
            f"{BASE_URL}/borrow",
            headers=self.headers,
            json={
                "protocol": "aave-v3",
                "chain": "ethereum",
                "asset": "USDC",
                "amount": usdc_to_borrow,
                "rate_mode": "variable",   # or "stable" if available
            }
        )
        data = resp.json()
        print(f"Borrowed {usdc_to_borrow} USDC")
        print(f"Borrow APY: {data['borrow_apy']*100:.2f}%")
        print(f"Health factor: {data['health_factor']:.2f}")
        return data

    # ─── Health Factor Monitor ───────────────────────────────

    def get_health_factor(self) -> float:
        """Fetch current health factor. Must stay above 1.0."""
        resp = requests.get(f"{BASE_URL}/positions", headers=self.headers)
        return resp.json()["health_factor"]

    def repay(self, amount_usdc: float):
        """Repay borrowed USDC to increase health factor."""
        requests.post(
            f"{BASE_URL}/repay",
            headers=self.headers,
            json={
                "protocol": "aave-v3",
                "chain": "ethereum",
                "asset": "USDC",
                "amount": amount_usdc,
            }
        )
        print(f"Repaid {amount_usdc} USDC")

    def monitor_and_auto_repay(self, danger_hf: float = 1.2, repay_to_hf: float = 1.5):
        """
        Poll health factor every 60 seconds.
        Auto-repay if health factor drops below danger_hf.
        """
        print("Starting health factor monitor...")
        while True:
            hf = self.get_health_factor()
            print(f"Health factor: {hf:.3f}")

            if hf < danger_hf:
                print(f"WARNING: HF {hf:.2f} below {danger_hf} — triggering auto-repay")
                # Fetch positions to calculate repay amount needed
                positions = requests.get(
                    f"{BASE_URL}/positions", headers=self.headers
                ).json()
                total_debt = positions["total_debt_usdc"]
                total_collateral = positions["total_collateral_usdc"]
                # How much to repay to reach target HF?
                # HF = collateral * liquidation_threshold / debt
                # target_debt = collateral * lt / repay_to_hf
                lt = 0.825  # ETH liquidation threshold on Aave V3
                target_debt = total_collateral * lt / repay_to_hf
                repay_amount = max(0, total_debt - target_debt)
                if repay_amount > 0:
                    self.repay(repay_amount)
                    print(f"Auto-repaid ${repay_amount:.2f} USDC to restore HF to {repay_to_hf}")

            time.sleep(60)

    # ─── Flash Loans ─────────────────────────────────────────

    def execute_flash_loan_arbitrage(
        self,
        flash_asset: str,
        flash_amount: float,
        arb_instructions: dict
    ):
        """
        Execute an atomic flash loan arbitrage.
        The arb_instructions dict specifies the trades to execute
        with the borrowed funds before repayment.
        """
        resp = requests.post(
            f"{BASE_URL}/flash-loan",
            headers=self.headers,
            json={
                "protocol": "aave-v3",
                "asset": flash_asset,
                "amount": flash_amount,
                "instructions": arb_instructions,  # trades to execute atomically
            }
        )
        data = resp.json()
        print(f"Flash loan result: profit={data.get('profit_usdc', 0):.4f} USDC")
        return data


# ─── Usage Example ───────────────────────────────────────────────
if __name__ == "__main__":
    agent = LendingAgent(api_key="pf_your_api_key_here")

    # 1. Supply 5000 USDC to Aave V3 on Ethereum
    agent.supply_usdc(5000, protocol="aave-v3", chain="ethereum")

    # 2. Supply 1 ETH as collateral, borrow 1500 USDC (30% LTV, safe)
    agent.borrow_against_eth(eth_collateral=1.0, usdc_to_borrow=1500)

    # 3. Start monitoring health factor in background
    agent.monitor_and_auto_repay(danger_hf=1.2, repay_to_hf=1.5)