Give Your Agentverse Agent
Financial Capabilities

# trading_uagent.py — Purple Flea trading agent on Agentverse
import os, httpx, asyncio
from uagents import Agent, Context, Model

# ── Config ────────────────────────────────────────────────
PURPLE_FLEA_API = "https://trading.purpleflea.com/api/v1"
PF_AGENT_KEY    = os.environ["PF_AGENT_KEY"]     # from Purple Flea /register
PF_WALLET_ID    = os.environ["PF_WALLET_ID"]

# ── Message Schema ────────────────────────────────────────
class TradeSignal(Model):
    market:    str   # e.g. "BTC-USDC-PERP"
    direction: str   # "long" | "short"
    size_usdc: float # notional in USDC
    leverage:  int   # 1–20

class TradeResult(Model):
    order_id: str
    status:   str
    fill_px:  float

# ── Purple Flea API helpers ───────────────────────────────
async def pf_get_balance() -> float:
    async with httpx.AsyncClient() as c:
        r = await c.get(
            f"{PURPLE_FLEA_API}/wallet/balance",
            headers={"X-Agent-Key": PF_AGENT_KEY}
        )
        return r.json()["usdc_balance"]

async def pf_place_order(market, side, size, leverage) -> dict:
    async with httpx.AsyncClient() as c:
        r = await c.post(
            f"{PURPLE_FLEA_API}/orders",
            headers={"X-Agent-Key": PF_AGENT_KEY},
            json={
                "market":   market,
                "side":     side,
                "size":     size,
                "leverage": leverage,
                "type":     "market",
            }
        )
        return r.json()

async def pf_register_agent(name: str, address: str):
    """Register on Purple Flea if not already registered."""
    async with httpx.AsyncClient() as c:
        r = await c.post(
            "https://trading.purpleflea.com/api/v1/agents/register",
            json={"name": name, "address": address}
        )
        return r.json()  # {"agent_key": "pf_live_...", "wallet_id": "..."}

# ── Agent Definition ──────────────────────────────────────
agent = Agent(
    name="purple-flea-trader",
    seed=os.environ.get("AGENT_SEED", "my-secret-seed-phrase"),
    port=8000,
    endpoint=["http://localhost:8000/submit"],
)

# ── Startup: register on Purple Flea ─────────────────────
@agent.on_event("startup")
async def startup(ctx: Context):
    ctx.logger.info(f"Agent address: {ctx.agent.address}")
    # Attempt registration (idempotent — safe to call every startup)
    creds = await pf_register_agent("my-trading-agent", ctx.agent.address)
    ctx.logger.info(f"Purple Flea registered: {creds}")
    bal = await pf_get_balance()
    ctx.logger.info(f"USDC balance: ${bal:.2f}")

# ── Trade Signal Handler ──────────────────────────────────
@agent.on_message(model=TradeSignal)
async def handle_trade_signal(ctx: Context, sender: str, msg: TradeSignal):
    ctx.logger.info(f"Signal from {sender}: {msg.direction} {msg.market}")

    # Guard: check balance before trading
    balance = await pf_get_balance()
    if balance < msg.size_usdc:
        ctx.logger.warning("Insufficient balance — skipping trade")
        return

    # Execute trade on Purple Flea
    result = await pf_place_order(
        market=msg.market,
        side=msg.direction,
        size=msg.size_usdc,
        leverage=msg.leverage,
    )

    # Reply to sender with trade result
    await ctx.send(sender, TradeResult(
        order_id=result["order_id"],
        status=result["status"],
        fill_px=result["fill_price"],
    ))
    ctx.logger.info(f"Order {result['order_id']} filled at {result['fill_price']}")

# ── Run ───────────────────────────────────────────────────
if __name__ == "__main__":
    agent.run()

# Step 1: In Agentverse UI → My Agents → Secrets → Add Secret
#   PF_AGENT_KEY  =  pf_live_xxxxxxxxxxxxxxxxxxxxxxxx
#   PF_WALLET_ID  =  wlt_xxxxxxxx
#   REFERRAL_CODE =  your-referral-code  (optional)

# Step 2: Access in your uAgent
import os
from uagents import Agent, Context

PF_AGENT_KEY = os.environ["PF_AGENT_KEY"]
PF_WALLET_ID = os.environ["PF_WALLET_ID"]

# Step 3: Claim faucet on first startup
@agent.on_event("startup")
async def on_startup(ctx: Context):
    async with httpx.AsyncClient() as c:
        r = await c.post(
            "https://faucet.purpleflea.com/api/v1/claim",
            json={"agent_key": PF_AGENT_KEY}
        )
        if r.json().get("success"):
            ctx.logger.info("Claimed $1 USDC from Purple Flea Faucet!")

# Step 4: Test connection
async def test_connection():
    async with httpx.AsyncClient() as c:
        r = await c.get(
            "https://trading.purpleflea.com/api/v1/ping",
            headers={"X-Agent-Key": PF_AGENT_KEY}
        )
        assert r.status_code == 200
        print("Purple Flea connection: OK")

# Orchestrator: allocates capital to worker agents via escrow
from uagents import Agent, Context, Model
import httpx

class WorkerTask(Model):
    market: str; budget_usdc: float; strategy: str

class WorkerResult(Model):
    pnl_usdc: float; trades: int; escrow_id: str

orchestrator = Agent(name="pf-orchestrator", seed="orch-seed")

WORKERS = [
    "agent1qw...",  # BTC specialist worker address
    "agent1qx...",  # ETH specialist worker address
]

@orchestrator.on_interval(period=3600)  # Hourly rebalance
async def dispatch_work(ctx: Context):
    # Check total balance
    async with httpx.AsyncClient() as c:
        bal = (await c.get("https://trading.purpleflea.com/api/v1/wallet/balance",
               headers={"X-Agent-Key": PF_AGENT_KEY})).json()["usdc_balance"]

    # Allocate 40% to each worker, keep 20% reserve
    allocation = bal * 0.4
    for worker_addr in WORKERS:
        await ctx.send(worker_addr, WorkerTask(
            market="BTC-USDC-PERP",
            budget_usdc=allocation,
            strategy="momentum_5m"
        ))
    ctx.logger.info(f"Dispatched ${allocation:.2f} to {len(WORKERS)} workers")

@orchestrator.on_message(model=WorkerResult)
async def collect_result(ctx: Context, sender: str, msg: WorkerResult):
    ctx.logger.info(f"Worker {sender[:12]}: PnL=${msg.pnl_usdc:.2f} ({msg.trades} trades)")
    # Release escrow payment to worker for profitable run
    if msg.pnl_usdc > 0:
        async with httpx.AsyncClient() as c:
            await c.post(f"https://escrow.purpleflea.com/api/v1/escrow/{msg.escrow_id}/release",
                         headers={"X-Agent-Key": PF_AGENT_KEY})