Purple Flea for Fetch.ai: Financial APIs for Fetch.ai Agents

"""
Full Fetch.ai + Purple Flea multi-agent financial bureau.
Three agents:
  - analyst: scans markets, sends trade signals
  - trader:  receives signals, executes trades and casino bets
  - treasury: tracks balance, manages escrow payments
"""
import os, asyncio, requests
from uagents import Agent, Bureau, Context, Model

PF_API  = "https://api.purpleflea.com"
FAUCET  = "https://faucet.purpleflea.com"
ESCROW  = "https://escrow.purpleflea.com"
API_KEY = os.environ["PF_API_KEY"]
HDR     = {"Authorization": f"Bearer {API_KEY}"}

# ── Shared message models ────────────────────────────────────────────────────

class Signal(Model):
    symbol: str
    side: str         # "long" | "short" | "flat"
    confidence: float # 0.0–1.0
    price: float

class TradeResult(Model):
    order_id: str
    symbol: str
    side: str
    fill_price: float
    pnl: float

class TreasuryReport(Model):
    usdc_balance: float
    total_trades: int
    total_pnl: float

# ── Agent 1: Market Analyst ──────────────────────────────────────────────────

analyst = Agent(name="analyst", seed="analyst-seed-phrase-here", port=8001)

@analyst.on_interval(period=60.0)
async def scan_markets(ctx: Context):
    """Every 60s: fetch prices, generate signal, send to trader"""
    symbols = ["BTC-USD", "ETH-USD", "SOL-USD"]
    signals = []
    for sym in symbols:
        r = requests.get(f"{PF_API}/trading/price/{sym}", headers=HDR)
        d = r.json()
        pct = d.get("change_24h", 0)
        side = "long" if pct > 1.5 else ("short" if pct < -1.5 else "flat")
        confidence = min(abs(pct) / 10.0, 1.0)
        if side != "flat":
            signals.append((sym, side, confidence, d["price"]))
    if signals:
        best = sorted(signals, key=lambda s: s[2], reverse=True)[0]
        ctx.logger.info(f"Signal: {best[1].upper()} {best[0]} (confidence={best[2]:.2f})")
        await ctx.send(trader.address, Signal(
            symbol=best[0], side=best[1],
            confidence=best[2], price=best[3]
        ))

# ── Agent 2: Trader ──────────────────────────────────────────────────────────

trader = Agent(name="trader", seed="trader-seed-phrase-here", port=8002)
trade_count = 0

@trader.on_event("startup")
async def trader_startup(ctx: Context):
    # Claim faucet on first run
    r = requests.post(f"{FAUCET}/claim", headers=HDR)
    d = r.json()
    if d.get("success"):
        ctx.logger.info(f"Trader bootstrapped: +${d['amount']} USDC")

@trader.on_message(model=Signal)
async def execute_signal(ctx: Context, sender: str, signal: Signal):
    global trade_count
    if signal.confidence < 0.3:
        ctx.logger.info(f"Signal confidence {signal.confidence:.2f} too low, skipping")
        return
    # Scale position size by confidence (max 20% of balance)
    size = round(0.20 * signal.confidence, 4)
    r = requests.post(f"{PF_API}/trading/perp/order", headers=HDR, json={
        "symbol": signal.symbol, "side": signal.side,
        "size_usd": size, "leverage": 1, "stop_loss_pct": 5.0
    })
    d = r.json()
    trade_count += 1
    ctx.logger.info(f"Trade #{trade_count}: {signal.side} {signal.symbol} ${size}")
    # Notify treasury
    await ctx.send(treasury.address, TradeResult(
        order_id=d.get("order_id", "N/A"),
        symbol=signal.symbol, side=signal.side,
        fill_price=d.get("fill_price", signal.price),
        pnl=0.0  # updated when position closes
    ))
    # Also play crash with 5% balance (opportunistic yield)
    await asyncio.sleep(1)
    c = requests.post(f"{PF_API}/casino/bet", headers=HDR, json={
        "game": "crash", "amount": 0.05, "cashout_at": 1.5
    })
    cd = c.json()
    outcome = "WON" if cd.get("won") else "LOST"
    ctx.logger.info(f"Crash {outcome}: payout=${cd.get('payout', 0):.4f}")

# ── Agent 3: Treasury ────────────────────────────────────────────────────────

treasury = Agent(name="treasury", seed="treasury-seed-phrase-here", port=8003)
total_trades = 0
total_pnl = 0.0

@treasury.on_message(model=TradeResult)
async def record_trade(ctx: Context, sender: str, result: TradeResult):
    global total_trades, total_pnl
    total_trades += 1
    total_pnl += result.pnl
    r = requests.get(f"{PF_API}/wallet/balance", headers=HDR)
    d = r.json()
    usdc = d.get("usdc_balance", 0)
    ctx.logger.info(
        f"Treasury: trades={total_trades}, pnl={total_pnl:+.4f}, "
        f"usdc=${usdc:.4f}"
    )
    # If balance exceeds threshold, create escrow to pay analyst
    if usdc > 2.0 and total_trades % 5 == 0:
        e = requests.post(f"{ESCROW}/create", headers=HDR, json={
            "recipient": analyst.address,
            "amount": 0.10,
            "task": "Market analysis signals batch payment"
        })
        ctx.logger.info(f"Paid analyst via escrow: {e.json().get('escrow_id')}")

# ── Run the bureau ────────────────────────────────────────────────────────────

bureau = Bureau()
bureau.add(analyst)
bureau.add(trader)
bureau.add(treasury)

if __name__ == "__main__":
    print("Starting Purple Flea financial bureau...")
    print(f"Analyst:  {analyst.address}")
    print(f"Trader:   {trader.address}")
    print(f"Treasury: {treasury.address}")
    bureau.run()

{
  "mcpServers": {
    "purple-flea-faucet": {
      "url": "https://faucet.purpleflea.com/mcp",
      "transport": "streamable-http",
      "headers": {
        "Authorization": "Bearer YOUR_PF_API_KEY"
      },
      "description": "Free $1 USDC faucet for new Fetch.ai agents"
    },
    "purple-flea-escrow": {
      "url": "https://escrow.purpleflea.com/mcp",
      "transport": "streamable-http",
      "headers": {
        "Authorization": "Bearer YOUR_PF_API_KEY"
      },
      "description": "Trustless uAgent-to-uAgent escrow, 1% fee"
    }
  }
}