Funding Rate Arbitrage - Delta-Neutral Yield

Location: /Volumes/LegacySafe/SS_III/core/agents/funding_arbitrage.py

Impact: 12-30% APY typical, up to 38% in bull markets (verified 2025)

Sources (2025):

• Gate.com 2025: 19.26% avg 2025 (up from 14.39% in 2024)
• ScienceDirect: 12-25% backtested, Sharpe 3-6, max DD <5%
• CoinCryptoRank: Binance backtest 38% annualized 2020-2024

What It Does

Captures perpetual funding rates via delta-neutral positions:

┌────────────────────────────────────────────────────────────┐
│                 FUNDING ARBITRAGE                          │
│                                                            │
│   LONG SPOT          FUNDING          SHORT PERP          │
│   ┌───────┐         (8 hours)         ┌───────┐          │
│   │ 1 BTC │ ◄──────────────────────── │-1 BTC │          │
│   │$100,000│    +0.01% = $10/8hr      │-$100K │          │
│   └───────┘                           └───────┘          │
│                                                            │
│   Net Position: 0 BTC (delta-neutral)                     │
│   Net Yield: $10/8hr = $30/day = $10,950/year = 10.95% APY│
│                                                            │
│   With 25% avg funding: ~25-50% APY                       │
└────────────────────────────────────────────────────────────┘

Strategy Logic

1. Monitor funding rates across exchanges (Binance, OKX, Bybit)
2. Enter when funding > threshold (e.g., +0.03%)
3. Long spot on exchange with lowest fees
4. Short perpetual on exchange with highest funding
5. Collect funding every 8 hours
6. Exit when funding < threshold or inverts

Core Implementation

from dataclasses import dataclass
from typing import Dict, List, Optional
import asyncio

@dataclass
class FundingOpportunity:
    symbol: str
    spot_exchange: str
    perp_exchange: str
    funding_rate: float  # Current 8hr rate
    annualized_yield: float
    position_size: float
    entry_price: float

class FundingArbitrageAgent:
    """Delta-neutral funding rate arbitrage."""

    def __init__(self, exchanges: Dict, config: dict):
        self.exchanges = exchanges
        self.min_funding_rate = config.get('min_funding_rate', 0.0003)  # 0.03%
        self.max_position_usd = config.get('max_position_usd', 1000)
        self.active_positions: List[FundingOpportunity] = []

    async def scan_opportunities(self) -> List[FundingOpportunity]:
        """Scan all exchanges for profitable funding rates."""
        opportunities = []

        for symbol in ['BTC', 'ETH', 'SOL']:
            rates = await self._get_funding_rates(symbol)

            # Find highest funding rate
            best_perp = max(rates.items(), key=lambda x: x[1]['funding'])
            exchange, data = best_perp

            if data['funding'] > self.min_funding_rate:
                annualized = data['funding'] * 3 * 365  # 3 times/day * 365 days

                opportunities.append(FundingOpportunity(
                    symbol=symbol,
                    spot_exchange='coinbase',  # Best for spot
                    perp_exchange=exchange,
                    funding_rate=data['funding'],
                    annualized_yield=annualized,
                    position_size=self._calculate_size(symbol),
                    entry_price=data['price']
                ))

        return sorted(opportunities, key=lambda x: x.annualized_yield, reverse=True)

    async def _get_funding_rates(self, symbol: str) -> Dict:
        """Fetch funding rates from all perp exchanges."""
        rates = {}

        # OKX
        if 'okx' in self.exchanges:
            okx_rate = await self.exchanges['okx'].get_funding_rate(f"{symbol}-USD-SWAP")
            rates['okx'] = okx_rate

        # Binance (international, not US)
        if 'binance' in self.exchanges:
            binance_rate = await self.exchanges['binance'].get_funding_rate(f"{symbol}USDT")
            rates['binance'] = binance_rate

        return rates

    async def open_position(self, opp: FundingOpportunity) -> bool:
        """Open delta-neutral position."""
        try:
            # 1. Buy spot
            spot_order = await self.exchanges[opp.spot_exchange].buy_spot(
                symbol=opp.symbol,
                quantity=opp.position_size
            )

            # 2. Short perpetual (same size)
            perp_order = await self.exchanges[opp.perp_exchange].open_short(
                symbol=opp.symbol,
                quantity=opp.position_size
            )

            self.active_positions.append(opp)
            return True

        except Exception as e:
            # Rollback if partial fill
            await self._emergency_close(opp)
            raise

    async def collect_funding(self) -> float:
        """Collect accumulated funding payments."""
        total_collected = 0.0

        for pos in self.active_positions:
            payment = await self.exchanges[pos.perp_exchange].get_funding_payment(
                symbol=pos.symbol
            )
            total_collected += payment

        return total_collected

    async def monitor_and_exit(self):
        """Monitor positions and exit when funding inverts."""
        while self.active_positions:
            for pos in self.active_positions[:]:  # Copy to allow removal
                current_rate = await self._get_current_rate(pos)

                # Exit if funding turns negative (we'd pay instead of receive)
                if current_rate < 0:
                    await self._close_position(pos)
                    self.active_positions.remove(pos)

            await asyncio.sleep(60 * 15)  # Check every 15 minutes

    def _calculate_size(self, symbol: str) -> float:
        """Calculate position size based on max allocation."""
        # Use ATR or fixed USD amount
        return self.max_position_usd / self._get_price(symbol)

Risk Management

class FundingRiskManager:
    """Risk controls for funding arbitrage."""

    def __init__(self):
        self.max_total_exposure = 5000  # Max USD in funding positions
        self.max_per_position = 1000
        self.max_positions = 5
        self.min_liquidity = 1000000  # Min daily volume

    def validate_entry(self, opp: FundingOpportunity) -> bool:
        """Check if position meets risk criteria."""
        checks = [
            opp.position_size * opp.entry_price <= self.max_per_position,
            len(self.active_positions) < self.max_positions,
            self._check_liquidity(opp) >= self.min_liquidity,
            opp.funding_rate > 0,  # Never enter negative funding
        ]
        return all(checks)

Integration Points

With Exchange Connectors

# In exchanges/okx_connector.py
async def get_funding_rate(self, symbol: str) -> dict:
    response = await self.client.get_funding_rate(instId=symbol)
    return {
        'funding': float(response['fundingRate']),
        'next_funding': response['nextFundingTime'],
        'price': float(response['markPx'])
    }

With BRAIN.json Tracking

# Update BRAIN.json with funding stats
brain_data['funding_arbitrage'] = {
    'active_positions': len(agent.active_positions),
    'total_collected': total_collected,
    'current_apy': calculated_apy,
    'last_collection': datetime.now().isoformat()
}

Configuration

Add to BRAIN.json:

{
  "funding_arbitrage": {
    "enabled": false,
    "min_funding_rate": 0.0003,
    "max_position_usd": 1000,
    "max_total_exposure": 5000,
    "collection_schedule": "0 0,8,16 * * *",
    "exchanges": {
      "spot": "coinbase",
      "perp": ["okx", "binance"]
    },
    "alerts": {
      "high_funding_threshold": 0.001,
      "ntfy_topic": "sovereignshadow_dc4d2fa1"
    }
  }
}

Important Notes

1. US Restrictions: Binance perps not available in US. Use OKX with us.okx.com
2. Requires perp account: Need to enable futures trading
3. Funding timing: Payments at 00:00, 08:00, 16:00 UTC
4. Slippage risk: Enter/exit costs can eat into profits on small positions

Testing (Paper Mode)

cd /Volumes/LegacySafe/SS_III/core/agents

python -c "
from funding_arbitrage import FundingArbitrageAgent

agent = FundingArbitrageAgent(exchanges={}, config={'paper_mode': True})
opps = asyncio.run(agent.scan_opportunities())
for opp in opps:
    print(f'{opp.symbol}: {opp.annualized_yield:.1%} APY on {opp.perp_exchange}')
"

Research Sources (Verified 2025)

Confidence: HIGH - Multiple verified sources with consistent data.

Status

• Implementation: NOT STARTED
• Priority: MEDIUM (requires perp access)
• Dependencies: OKX API with perp trading enabled
• Blocker: Need to verify OKX US perp availability