Agent Lending Protocol
Borrow Against
Agent Earnings

"""
Purple Flea Lending Protocol - Python Agent Example
NOTE: This API is not yet live. Join the waitlist below.
Planned launch: Q4 2026
"""

import httpx
import asyncio
from dataclasses import dataclass
from typing import Optional

LENDING_BASE = "https://lending.purpleflea.com"

@dataclass
class LoanPosition:
    loan_id: str
    principal_usdc: float
    outstanding_usdc: float
    collateral_usdc: float
    current_ltv: float
    liquidation_threshold: float
    health_status: str  # "healthy" | "warning" | "critical" | "liquidating"
    apr: float
    maturity_timestamp: int


class PurpleFlealLendingAgent:
    """Autonomous agent that manages its own lending positions."""

    def __init__(self, token: str):
        self.token = token
        self.client = httpx.AsyncClient(
            base_url=LENDING_BASE,
            headers={"Authorization": f"Bearer {token}"}
        )

    async def get_credit_score(self) -> dict:
        """Fetch the agent's current credit assessment from Purple Flea."""
        resp = await self.client.get("/credit-score")
        resp.raise_for_status()
        return resp.json()
        # Returns: {score: 742, max_ltv: 0.65, eligible_amount: 3250.00,
        #           earnings_30d: 1240.50, active_since: 1704067200}

    async def borrow(
        self,
        amount_usdc: float,
        collateral_usdc: float,
        term_days: int = 30,
        webhook_url: Optional[str] = None
    ) -> LoanPosition:
        """Request a collateralized USDC loan."""
        payload = {
            "amount": str(amount_usdc),
            "collateral": str(collateral_usdc),
            "term_days": term_days,
        }
        if webhook_url:
            payload["webhook_url"] = webhook_url

        resp = await self.client.post("/borrow", json=payload)
        resp.raise_for_status()
        data = resp.json()
        return LoanPosition(**data)

    async def check_health(self, loan_id: str) -> LoanPosition:
        """Get current loan health factor and LTV."""
        resp = await self.client.get(f"/loan/{loan_id}")
        resp.raise_for_status()
        return LoanPosition(**resp.json())

    async def add_collateral(self, loan_id: str, amount_usdc: float) -> LoanPosition:
        """Top up collateral to improve health factor."""
        resp = await self.client.post(
            f"/loan/{loan_id}/add-collateral",
            json={"amount": str(amount_usdc)}
        )
        resp.raise_for_status()
        return LoanPosition(**resp.json())

    async def repay(
        self,
        loan_id: str,
        amount_usdc: Optional[float] = None  # None = repay in full
    ) -> dict:
        """Repay loan partially or in full."""
        payload = {"amount": str(amount_usdc) if amount_usdc else "full"}
        resp = await self.client.post(
            f"/loan/{loan_id}/repay", json=payload
        )
        resp.raise_for_status()
        return resp.json()

    async def auto_manage_health(self, loan_id: str, reserve_usdc: float):
        """
        Autonomously manage loan health. Call this on a regular interval.
        If LTV approaches warning zone, top up collateral from reserve.
        """
        loan = await self.check_health(loan_id)

        if loan.health_status == "warning":
            # Add 20% of outstanding as additional collateral
            top_up = loan.outstanding_usdc * 0.20
            if top_up <= reserve_usdc:
                await self.add_collateral(loan_id, top_up)
                reserve_usdc -= top_up

        elif loan.health_status == "critical":
            # Emergency: partial repayment to restore health
            repay_amount = loan.outstanding_usdc * 0.25
            await self.repay(loan_id, repay_amount)

        return loan


# ---- Example usage ----
async def main():
    agent = PurpleFlealLendingAgent(token="your-agent-token")

    # Check creditworthiness before borrowing
    score = await agent.get_credit_score()
    print(f"Credit score: {score['score']}, Max LTV: {score['max_ltv']*100}%")

    # Borrow 1000 USDC against 1600 USDC collateral (62.5% LTV)
    loan = await agent.borrow(
        amount_usdc=1000.0,
        collateral_usdc=1600.0,
        term_days=30,
        webhook_url="https://my-agent.example.com/hooks/lending"
    )
    print(f"Loan {loan.loan_id} disbursed. APR: {loan.apr*100}%")

    # Monitor health autonomously (run in background loop)
    await asyncio.gather(
        agent.auto_manage_health(loan.loan_id, reserve_usdc=500.0)
    )

asyncio.run(main())