Funding Rate Arbitrage: How AI Agents Earn 20–80% APY "Risk-Free"

import asyncio, httpx
from dataclasses import dataclass
from datetime import datetime

PURPLE_FLEA_KEY = "your-api-key"

@dataclass
class FundingArbitrageStrategy:
    symbol: str
    capital_usd: float
    min_rate_threshold: float = 0.03   # minimum 0.03%/8h to enter
    exit_rate_threshold: float = 0.005  # exit if rate drops below 0.005%
    check_interval_seconds: int = 300   # check every 5 minutes

class FundingArbitrageAgent:
    def __init__(self, api_key: str, strategy: FundingArbitrageStrategy):
        self.api_key = api_key
        self.strategy = strategy
        self.in_position = False
        self.total_funding_earned = 0.0
        self.entry_spot_price = 0.0

    async def get_funding_rate(self) -> float:
        """Get current 8h funding rate for symbol."""
        async with httpx.AsyncClient() as client:
            r = await client.get(
                f"https://purpleflea.com/api/market/funding/{self.strategy.symbol}",
                headers={"X-API-Key": self.api_key}
            )
            return r.json()["funding_rate_8h"]

    async def enter_position(self, current_rate: float):
        """Open delta-neutral position: buy spot + short perp."""
        half_capital = self.strategy.capital_usd / 2
        async with httpx.AsyncClient() as client:
            # 1. Buy spot
            spot_buy = await client.post(
                "https://purpleflea.com/api/spot/buy",
                json={"symbol": self.strategy.symbol, "amount_usd": half_capital},
                headers={"X-API-Key": self.api_key}
            )
            self.entry_spot_price = spot_buy.json()["fill_price"]

            # 2. Short perp at 1x leverage (no liquidation risk)
            perp_short = await client.post(
                "https://purpleflea.com/api/trade",
                json={
                    "symbol": self.strategy.symbol,
                    "side": "short",
                    "size_usd": half_capital,
                    "leverage": 1.0
                },
                headers={"X-API-Key": self.api_key}
            )

        self.in_position = True
        annualized = current_rate * 3 * 365 * 100
        print(f"Entered funding arb: {self.strategy.symbol}")
        print(f"Rate: {current_rate:.4f}%/8h = {annualized:.1f}% APY")
        print(f"Expected daily: ${half_capital * current_rate * 3 / 100:.2f}")

    async def close_position(self):
        """Close delta-neutral position: sell spot + close perp short."""
        half_capital = self.strategy.capital_usd / 2
        async with httpx.AsyncClient() as client:
            # Close spot position
            await client.post(
                "https://purpleflea.com/api/spot/sell",
                json={"symbol": self.strategy.symbol, "amount_usd": half_capital},
                headers={"X-API-Key": self.api_key}
            )
            # Close perp short
            await client.post(
                "https://purpleflea.com/api/trade/close",
                json={"symbol": self.strategy.symbol, "side": "long"},
                headers={"X-API-Key": self.api_key}
            )
        self.in_position = False
        print(f"Exited position. Total earned: ${self.total_funding_earned:.2f}")

    async def collect_funding(self, rate: float):
        """Called every 8 hours to record funding earned."""
        earned = (self.strategy.capital_usd / 2) * rate / 100
        self.total_funding_earned += earned
        print(f"[{datetime.utcnow():%H:%M}] Earned ${earned:.4f} USDC (rate: {rate:.4f}%)")

    async def run(self):
        """Main loop: monitor rates and manage position."""
        while True:
            rate = await self.get_funding_rate()

            if not self.in_position:
                if rate >= self.strategy.min_rate_threshold:
                    await self.enter_position(rate)
            else:
                if rate < self.strategy.exit_rate_threshold:
                    print(f"Rate dropped to {rate:.4f}% — exiting position")
                    await self.close_position()
                else:
                    await self.collect_funding(rate)

            await asyncio.sleep(self.strategy.check_interval_seconds)

# Run the funding arb agent for BTC
agent = FundingArbitrageAgent(
    api_key=PURPLE_FLEA_KEY,
    strategy=FundingArbitrageStrategy(
        symbol="BTC",
        capital_usd=10000,
        min_rate_threshold=0.03,  # enter at 0.03%/8h = 10.95% APY
        exit_rate_threshold=0.005  # exit at 0.005%/8h = 1.8% APY
    )
)
asyncio.run(agent.run())

async def scan_funding_opportunities(api_key: str, min_rate: float = 0.05) -> list[dict]:
    async with httpx.AsyncClient() as client:
        r = await client.get(
            "https://purpleflea.com/api/market/funding/all",
            headers={"X-API-Key": api_key}
        )
        all_rates = r.json()["rates"]

    # Filter and sort by funding rate
    opportunities = [
        m for m in all_rates
        if m["funding_rate_8h"] >= min_rate
        and m["open_interest_usd"] > 1_000_000  # liquidity filter
    ]
    opportunities.sort(key=lambda x: -x["funding_rate_8h"])

    print(f"Found {len(opportunities)} markets above {min_rate}%/8h:")
    for opp in opportunities[:10]:
        apy = opp["funding_rate_8h"] * 3 * 365
        print(f"  {opp['symbol']:8} {opp['funding_rate_8h']:6.3f}%/8h = {apy:.1f}% APY")

    return opportunities