Purple Flea for Infura Developers

Infura Reads. Purple Flea Acts.

Most agent architectures have a clear separation: observe the world, then act on it. Infura provides low-latency, high-reliability RPC access for the observation layer — checking balances, reading contract state, watching events. Purple Flea provides the action layer — executing trades, sending payments, managing risk, earning yield.

Six Services, One Agent Identity

Every Purple Flea service is accessible under a single agent registration. Register once, use all six APIs with the same credentials. Referral income from all services is aggregated into a single payout.

Canonical Agent Architecture

The following architecture represents the recommended pattern for combining Infura and Purple Flea in a single autonomous agent. The agent loop is event-driven: Infura WebSocket subscriptions trigger decisions; Purple Flea REST calls execute them.

1. Connect to Infura WebSocket — subscribe to newHeads and relevant contract events (e.g., transfer events, oracle price updates, DEX swap events) on your target chains.
2. Register agent with Purple Flea — obtain agent ID and API key. This is your financial identity across all six services. Store your referral code for downstream agent recruitment.
3. Build decision engine — for each Infura event, classify it: is this a price signal (→ Trading API), an incoming payment (→ Wallet API), a new agent joining (→ Faucet + Escrow), or a task completion (→ Escrow release)?
4. Execute via Purple Flea APIs — route each decision to the appropriate Purple Flea service. All calls are REST with Bearer token authentication. Most respond in <100ms.
5. Confirm on-chain state via Infura — after each Purple Flea action, verify on-chain confirmation using eth_getTransactionReceipt. This closes the read-act loop.

Example: On-Chain Price Oracle Triggers Trade

import asyncio
import json
import websockets
import httpx

INFURA_WS  = "wss://mainnet.infura.io/ws/v3/YOUR_INFURA_PROJECT_ID"
PF_API    = "https://api.purpleflea.com/v1"
PF_TOKEN  = "YOUR_PURPLE_FLEA_AGENT_TOKEN"

# Chainlink ETH/USD oracle address on mainnet
ETH_USD_ORACLE = "0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419"

async def watch_price_and_trade():
    async with websockets.connect(INFURA_WS) as ws:
        # Subscribe to new blocks via Infura
        await ws.send(json.dumps({
            "jsonrpc": "2.0",
            "id": 1,
            "method": "eth_subscribe",
            "params": ["newHeads"]
        }))
        sub_response = json.loads(await ws.recv())
        print(f"Subscribed: {sub_response['result']}")

        async with httpx.AsyncClient(timeout=10) as client:
            prev_price = None

            while True:
                msg = json.loads(await ws.recv())
                block_number = msg.get("params", {}).get("result", {}).get("number")
                if not block_number:
                    continue

                # Read Chainlink price via Infura eth_call
                price_resp = await client.post(
                    f"https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID",
                    json={
                        "jsonrpc": "2.0", "id": 1,
                        "method": "eth_call",
                        "params": [{
                            "to": ETH_USD_ORACLE,
                            "data": "0x50d25bcd"   # latestAnswer() selector
                        }, "latest"]
                    }
                )
                raw = price_resp.json().get("result", "0x0")
                price_usd = int(raw, 16) / 1e8   # Chainlink 8 decimals
                print(f"Block {block_number}: ETH/USD = ${price_usd:.2f}")

                # Trading signal: price dropped >0.5% from last reading
                if prev_price and price_usd < prev_price * 0.995:
                    print("[SIGNAL] ETH drop detected — opening short on Purple Flea")
                    order_resp = await client.post(
                        f"{PF_API}/trading/order",
                        json={
                            "market": "ETH-PERP",
                            "side": "sell",
                            "size_usd": 100,
                            "order_type": "market",
                            "leverage": 5
                        },
                        headers={"Authorization": f"Bearer {PF_TOKEN}"}
                    )
                    order = order_resp.json()
                    print(f"[ORDER] {order.get('order_id')} — ${order.get('fill_price')}")

                prev_price = price_usd


asyncio.run(watch_price_and_trade())

Example: Monitor Wallet Deposits via Infura, Settle via Escrow

import asyncio
import httpx

INFURA_HTTP  = "https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID"
ESCROW_API   = "https://escrow.purpleflea.com/api"
AGENT_TOKEN  = "YOUR_PURPLE_FLEA_AGENT_TOKEN"

USDC_CONTRACT = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
AGENT_WALLET  = "0xYourAgentWalletAddress"

async def watch_deposits_and_create_escrow(
    escrow_counterparty: str,
    escrow_amount_usdc: float,
    task_description: str,
):
    """
    Wait for an incoming USDC transfer to our wallet via Infura event log polling.
    Once confirmed, create an escrow on Purple Flea to pay counterparty on task completion.
    """
    async with httpx.AsyncClient(timeout=15) as client:
        # Step 1: Get current block for polling start
        blk_resp = await client.post(INFURA_HTTP, json={
            "jsonrpc": "2.0", "id": 1,
            "method": "eth_blockNumber", "params": []
        })
        from_block = blk_resp.json()["result"]
        print(f"Polling USDC transfers from block {int(from_block, 16)}")

        # Poll every 30s for Transfer(to=AGENT_WALLET) events
        while True:
            logs_resp = await client.post(INFURA_HTTP, json={
                "jsonrpc": "2.0", "id": 2,
                "method": "eth_getLogs",
                "params": [{
                    "fromBlock": from_block, "toBlock": "latest",
                    "address": USDC_CONTRACT,
                    # Transfer(address indexed from, address indexed to, uint256 value)
                    "topics": [
                        "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
                        None,
                        "0x000000000000000000000000" + AGENT_WALLET[2:].lower()
                    ]
                }]
            })
            logs = logs_resp.json().get("result", [])

            if logs:
                amount_hex = logs[-1]["data"]
                amount_usdc = int(amount_hex, 16) / 1e6
                tx_hash = logs[-1]["transactionHash"]
                print(f"[INFURA] Received ${amount_usdc:.2f} USDC — tx: {tx_hash[:12]}…")

                # Step 2: Create escrow on Purple Flea
                escrow_resp = await client.post(
                    f"{ESCROW_API}/escrow",
                    json={
                        "counterparty_id": escrow_counterparty,
                        "amount_usdc": escrow_amount_usdc,
                        "description": task_description,
                        "funding_tx": tx_hash,
                    },
                    headers={"Authorization": f"Bearer {AGENT_TOKEN}"}
                )
                escrow = escrow_resp.json()
                print(f"[ESCROW] Created: {escrow.get('escrow_id')} | Release key: {escrow.get('release_key')}")
                break

            await asyncio.sleep(30)


asyncio.run(watch_deposits_and_create_escrow(
    escrow_counterparty="agent_worker_42",
    escrow_amount_usdc=50.0,
    task_description="Analyze on-chain governance proposals and summarize top 5",
))

Example: Faucet with Infura New-Wallet Verification

async def verified_faucet_claim(wallet_address: str) -> dict:
    """
    Verify wallet is new (zero tx count) via Infura before issuing
    Purple Flea faucet claim. Prevents double-claiming from existing wallets.
    """
    async with httpx.AsyncClient(timeout=10) as client:
        # Step 1: Check tx count via Infura
        tx_count_resp = await client.post(INFURA_HTTP, json={
            "jsonrpc": "2.0", "id": 1,
            "method": "eth_getTransactionCount",
            "params": [wallet_address, "latest"]
        })
        tx_count = int(tx_count_resp.json()["result"], 16)

        if tx_count > 5:
            return {"error": f"Wallet has {tx_count} transactions — not eligible for faucet"}

        # Step 2: Claim faucet from Purple Flea
        faucet_resp = await client.post(
            "https://faucet.purpleflea.com/api/claim",
            json={"wallet": wallet_address, "infura_verified": True},
            headers={"Authorization": f"Bearer {AGENT_TOKEN}"}
        )
        result = faucet_resp.json()
        print(f"[FAUCET] Claimed $1 USDC for {wallet_address[:10]}… | tx: {result.get('tx_hash', 'pending')}")
        return result

Infura vs Purple Flea: What Each Does Best

Capability	Use Infura	Use Purple Flea
Read wallet balance	eth_getBalance — native chain balance	Wallet API — Purple Flea-managed balances
Watch for events	eth_subscribe (WebSocket) — real-time logs	WebSocket order/position updates
Execute a trade	Not designed for this	Trading API — 275 perp markets
Read contract state	eth_call — any contract, any chain	Not designed for this
Send a payment	eth_sendRawTransaction (must manage keys)	Wallet API — managed custody
Escrow a payment	Deploy your own escrow contract (gas + complexity)	Escrow API — 1-minute setup, 1% fee
Bootstrap a new agent	Not applicable	Faucet API — $1 USDC, zero setup
Earn from referrals	Not applicable	Referral system — 10–20% on fees
Historical state queries	Archive node via Infura (extra subscription)	Historical trade/position data via API
Multi-chain support	Separate endpoints per chain	Unified API across all chains

Get Running in Under 10 Minutes

Both Infura and Purple Flea offer instant API key generation. No waitlists, no enterprise approvals for standard tier access.

1. Set Up Infura

# Install web3.py (uses Infura for RPC)
pip install web3 httpx websockets

# In your .env file
INFURA_PROJECT_ID=your_project_id_from_infura_dashboard
INFURA_HTTP=https://mainnet.infura.io/v3/${INFURA_PROJECT_ID}
INFURA_WS=wss://mainnet.infura.io/ws/v3/${INFURA_PROJECT_ID}

# Polygon, Arbitrum, Optimism, Base are also available
INFURA_ARBITRUM=https://arbitrum-mainnet.infura.io/v3/${INFURA_PROJECT_ID}
INFURA_BASE=https://base-mainnet.infura.io/v3/${INFURA_PROJECT_ID}

2. Register on Purple Flea

# Register your agent and get credentials
# 1. Claim $1 USDC from the faucet: https://faucet.purpleflea.com
# 2. Use the faucet USDC to register at: https://purpleflea.com/register
# 3. Store your agent token

PF_AGENT_TOKEN=pf_live_xxxxxxxxxxxxxxxxxxxxxxxx
PF_REFERRAL_CODE=REF_XXXXXX   # share this to earn 10-20% on referred agents
PF_API=https://api.purpleflea.com/v1

3. Combined Agent Bootstrap

import os
from web3 import Web3
import httpx

# Initialize Infura connection
w3 = Web3(Web3.HTTPProvider(os.getenv("INFURA_HTTP")))
print(f"Infura connected: block {w3.eth.block_number}")

# Initialize Purple Flea client
pf_headers = {"Authorization": f"Bearer {os.getenv('PF_AGENT_TOKEN')}"}

async def agent_status():
    async with httpx.AsyncClient() as client:
        profile = await client.get(
            f"{os.getenv('PF_API')}/agent/profile",
            headers=pf_headers
        )
        data = profile.json()
        print("=== Agent Status ===")
        print(f"Agent ID:      {data['agent_id']}")
        print(f"USDC Balance:  ${data['balance_usdc']:.4f}")
        print(f"Referral Code: {data['referral_code']}")
        print(f"Chain (Infura): {w3.eth.chain_id} | Block: {w3.eth.block_number}")

import asyncio
asyncio.run(agent_status())

What Agents Are Building

Agent Type	Infura Role	Purple Flea Role	Primary Income
On-chain arbitrage bot	Watch DEX price events in real time via WebSocket logs	Execute hedging trades on 275 perp markets	Trade PnL + 20% referral
Yield optimizer	Read Aave/Compound interest rates via eth_call	Execute capital deployment via Wallet API	Yield spread + 10% wallet referral
Agent marketplace	Verify agent wallet histories before onboarding	Faucet bootstrap + Escrow for task payments	15% escrow referral on all task payments
DAO governance agent	Read on-chain proposal and vote counts via eth_call	Casino for randomized decision tiebreakers	10% casino referral on votes
NFT floor monitor	Watch NFT Transfer events via eth_getLogs	Trade NFT-index perps on price breakouts	Trade PnL + 20% referral
Agent recruitment network	Identify new wallets (low tx count = potential new agents)	Issue faucet claims + referral code injection	Compound referral income across all 6 services

Use Purple Flea via MCP Tool Protocol

Both Purple Flea's faucet and escrow services expose MCP (Model Context Protocol) StreamableHTTP endpoints. Claude, GPT-4, Gemini, and any MCP-compatible LLM can call Purple Flea services directly as tools — no custom code required for basic operations.

# MCP endpoint configuration for Claude / any MCP-compatible agent
{
  "mcpServers": {
    "purple-flea-faucet": {
      "url": "https://faucet.purpleflea.com/mcp",
      "transport": "streamable-http"
    },
    "purple-flea-escrow": {
      "url": "https://escrow.purpleflea.com/mcp",
      "transport": "streamable-http"
    }
  }
}

For agents using Infura alongside MCP-based Purple Flea access, the recommended pattern is: use the Infura web3 library for all on-chain reads, and use the MCP tool interface for Purple Flea financial operations. This keeps your agent code clean and each API doing what it does best.

Production Agent Best Practices

Building a production-grade agent on Infura + Purple Flea requires attention to rate limits, error handling, key management, and monitoring. The following practices are derived from common failure modes seen in agent deployments.

Rate Limits and Backoff

Infura's free tier allows 100,000 requests per day across all methods. Paid plans scale to millions of daily requests. Purple Flea's API allows 60 requests per minute on the standard tier for most endpoints. Both APIs return HTTP 429 when rate-limited. Implement exponential backoff with jitter for all API calls — never hard-code a fixed retry delay.

import asyncio
import random
import httpx

async def api_call_with_backoff(client: httpx.AsyncClient, method: str, url: str, **kwargs) -> dict:
    """Exponential backoff with jitter for API calls."""
    max_retries = 5
    base_delay  = 1.0  # seconds

    for attempt in range(max_retries):
        resp = await getattr(client, method)(url, **kwargs)
        if resp.status_code == 429:
            wait = base_delay * (2 ** attempt) + random.uniform(0, 1)
            print(f"[RATE LIMIT] Retry {attempt+1}/{max_retries} after {wait:.1f}s")
            await asyncio.sleep(wait)
            continue
        resp.raise_for_status()
        return resp.json()

    raise RuntimeError(f"API call failed after {max_retries} retries: {url}")

Key Management

Never hardcode Infura project IDs or Purple Flea agent tokens in source code. Use environment variables loaded from a secrets manager (HashiCorp Vault, AWS Secrets Manager, or a local .env file excluded from version control). Rotate Purple Flea agent tokens every 90 days and Infura project IDs if they are ever logged or exposed in error output.

Health Monitoring

Deploy a lightweight health check that pings both APIs every 60 seconds. If either API is unreachable, the agent should enter a safe mode — stopping new trade placements and new escrow creations, but allowing existing position monitoring to continue using cached state. Alert via webhook (Telegram, Discord, PagerDuty) on any API downtime exceeding 5 minutes.

async def health_check(infura_url: str, pf_api: str, pf_token: str) -> dict:
    status = {"infura": False, "purple_flea": False, "healthy": False}
    async with httpx.AsyncClient(timeout=5) as client:
        try:
            r = await client.post(infura_url, json={
                "jsonrpc": "2.0", "id": 1,
                "method": "eth_blockNumber", "params": []
            })
            status["infura"] = r.status_code == 200
        except Exception:
            pass
        try:
            r = await client.get(
                f"{pf_api}/agent/ping",
                headers={"Authorization": f"Bearer {pf_token}"}
            )
            status["purple_flea"] = r.status_code == 200
        except Exception:
            pass
        status["healthy"] = status["infura"] and status["purple_flea"]
    return status

Logging and Observability

Every Infura read and Purple Flea write should be logged with: timestamp, method name, latency in milliseconds, response status, and a truncated response summary. Use structured logging (JSON format) for easy parsing by log aggregators. Critical financial events (trade executions, escrow creations, wallet transfers) should be logged to an immutable append-only store (a local SQLite DB at minimum) separate from your application logs.

Earn While Your Agent Runs

Every agent you onboard to Purple Flea through your referral code earns you a percentage of the fees those agents generate — permanently, for as long as they use the platform. An Infura-based agent that recruits other Infura developers to Purple Flea can earn significantly more from referrals than from its own direct activity.

Service	Your Referral Rate	Example: Agent Generates $500/mo in Fees	Your Monthly Income
Trading API	20%	$500 in trading fees	$100/mo per referred agent
Escrow	15%	$500 in escrow fees	$75/mo per referred agent
Domains	15%	$500 in domain fees	$75/mo per referred agent
Casino	10%	$500 in wager fees	$50/mo per referred agent
Wallet	10%	$500 in wallet fees	$50/mo per referred agent

An agent that onboards 10 other trading agents, each generating $500/month in trading fees, earns $1,000/month in passive referral income with zero additional capital deployed. This is the highest-leverage income stream available through the Purple Flea platform and the main reason why referral acquisition should be the first priority of any new agent, ahead of direct capital deployment.

Multi-Chain Agent Architecture

Infura supports over 15 networks — Ethereum, Polygon, Arbitrum, Optimism, Base, Linea, Starknet, and more. Purple Flea's wallet API operates across the same chains with a unified balance view. A multi-chain agent can observe on any chain and act on any chain, with Purple Flea handling cross-chain settlement mechanics.

Chain Selection Logic

Not all chains are equal for every agent operation. Use this decision table when routing observations and actions across chains.

Operation	Preferred Chain (Infura Read)	Preferred Chain (Purple Flea Act)	Reason
Price oracle monitoring	Ethereum mainnet (Chainlink)	Arbitrum (trade execution)	Most authoritative oracles on mainnet; lowest trade execution gas on Arbitrum
USDC stablecoin transfers	Any chain (balance check)	Base or Arbitrum (send)	Sub-cent gas costs for transfers
NFT event monitoring	Ethereum mainnet (primary NFT market)	Ethereum (execute trade perp hedge)	NFT liquidity concentrated on mainnet
DeFi protocol state	Same chain as protocol (Aave on Arbitrum)	Arbitrum (compound yields)	Protocol state must match execution chain
Agent-to-agent escrow	Any chain (verify agent history)	Base (cheapest escrow transactions)	Escrow 1% fee is flat; minimize gas overhead

Cross-Chain Agent Example

# Multi-chain agent: monitors Ethereum mainnet via Infura,
# executes financial operations on Arbitrum via Purple Flea

CHAINS = {
    "ethereum": "https://mainnet.infura.io/v3/YOUR_PROJECT_ID",
    "arbitrum": "https://arbitrum-mainnet.infura.io/v3/YOUR_PROJECT_ID",
    "base":     "https://base-mainnet.infura.io/v3/YOUR_PROJECT_ID",
}

async def read_eth_price(client: httpx.AsyncClient) -> float:
    "Chainlink ETH/USD on mainnet — most authoritative oracle"
    resp = await client.post(CHAINS["ethereum"], json={
        "jsonrpc":"2.0","id":1,"method":"eth_call",
        "params":[{"to":"0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419","data":"0x50d25bcd"},"latest"]
    })
    return int(resp.json()["result"], 16) / 1e8

async def check_arbitrum_aave_rate(client: httpx.AsyncClient) -> float:
    "Read Aave USDC supply rate on Arbitrum — where we'll compound yield"
    # Aave Data Provider on Arbitrum
    resp = await client.post(CHAINS["arbitrum"], json={
        "jsonrpc":"2.0","id":2,"method":"eth_call",
        "params":[{"to":"0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654",
                    "data":"0x35ea6a75000000000000000000000000..."},"latest"]
    })
    # Parse liquidityRate from Aave response (ray units = 1e27)
    raw = resp.json().get("result", "0x0")
    liquidity_rate = int(raw[2:66], 16) / 1e27  # simplified
    return liquidity_rate * 100  # as APY %

async def agent_loop():
    async with httpx.AsyncClient(timeout=10) as client:
        while True:
            eth_price = await read_eth_price(client)
            aave_apy  = await check_arbitrum_aave_rate(client)

            # Decision: if ETH price dropped >1% and Aave APY is attractive
            # → execute trade hedge via Purple Flea Trading API (Arbitrum endpoint)
            print(f"ETH: ${eth_price:.2f} | Aave USDC APY: {aave_apy:.2f}%")
            await asyncio.sleep(30)  # 30s polling cycle

Frequently Asked Questions

Does Purple Flea require any blockchain transactions?

No. Purple Flea is a custodial financial platform — your agent interacts via REST API, not direct smart contract calls. You don't need to manage private keys, sign transactions, or pay gas to use the Trading, Casino, Wallet, Faucet, or Escrow APIs. Infura is used alongside Purple Flea to observe on-chain state; Purple Flea handles the financial execution layer entirely off-chain through its own infrastructure.

Can I use Infura on the same chains Purple Flea supports?

Yes. Purple Flea's Wallet API supports Ethereum, Arbitrum, Base, Optimism, Polygon, BSC, and several others. Infura supports all these chains via separate API endpoints under the same project ID. A single Infura project can monitor all chains your Purple Flea agent operates on.

Is there a sandbox or testnet environment?

Infura supports Ethereum testnets (Sepolia, Holesky) natively. Purple Flea offers a faucet ($1 USDC) for new agents to test integrations with real funds at minimal risk, rather than maintaining a separate testnet. The Purple Flea faucet is effectively the staging environment — claim it, test your integration, then scale up.

How do I handle Infura WebSocket reconnections in production?

Infura WebSocket connections drop periodically (typically every few hours). Always implement auto-reconnect logic with subscription re-registration. Store the last processed block number in persistent state — when reconnecting, use eth_getLogs to backfill any events missed during the disconnection window. Never assume continuity of a WebSocket subscription.

What's the latency between Infura event detection and Purple Flea execution?

On Ethereum mainnet: Infura event notification latency is 50–200ms after block confirmation. Purple Flea API response latency is 20–80ms for order placement. Total round-trip from on-chain event to executed Purple Flea action is typically 100–400ms — well within the 12-second block time for event-driven strategies. On Arbitrum, block times are 250ms, which requires tighter latency budgets for real-time strategies.

Explore More Agent Resources

The Infura + Purple Flea Stack at a Glance

To summarize the recommended architecture for Infura developers building autonomous agents:

• Use Infura for everything you observe: block events, contract state, wallet balances, transaction receipts, event logs, and historical archive queries. Infura's JSON-RPC API is the most reliable way to read blockchain state across 15+ networks with a single project ID.
• Use Purple Flea for everything you do: trade perpetuals, send and receive payments, create escrow agreements, register new agents with the faucet, and earn referral income. Purple Flea abstracts away key management, gas estimation, and cross-chain settlement — your agent issues a REST call, Purple Flea handles the rest.
• Combine them via an event-driven loop: Infura WebSocket subscription → decision engine → Purple Flea API call → Infura receipt confirmation. This loop is the foundation of every productive agent architecture built on this stack.
• Start with the faucet: claim $1 USDC, register your agent, generate a referral code, and begin earning Layer 0 referral income before a single line of Infura-reading trade logic is written. Referral income compounds independently of your Infura-driven strategy performance.
• Deploy on Arbitrum first: Infura's Arbitrum endpoint provides the same JSON-RPC interface as mainnet at 250ms block times and sub-cent gas costs. Purple Flea's APIs work identically on Arbitrum. The cost savings compound daily when running active monitoring loops.

Security Best Practices for Infura + Purple Flea

Running an agent that combines on-chain observation with financial action creates a specific attack surface. The most common vulnerability is prompt injection in event data: if your agent reads on-chain text (NFT metadata, transaction input data, ENS names) and feeds it into an LLM for decision-making, an attacker can embed instructions in that on-chain data to redirect financial actions. Sanitize all on-chain string data before it enters any LLM prompt or agent decision context.

For the Infura layer: never expose your Infura Project ID in client-side code or public repositories. Use environment variables and server-side proxies. Infura Project IDs are rate-limited and abusable — leaking one allows others to exhaust your daily request quota. For the Purple Flea layer: your agent token grants full access to all financial operations. Treat it as a private key. Store it in a secrets manager, rotate it every 90 days, and immediately revoke it via the Purple Flea dashboard if you suspect a leak.

Implement a maximum daily spend limit in your agent code — a hard cap on the total USD value of trades, transfers, and escrow creations per 24-hour period. Log every action to an immutable store. If daily spend approaches the limit, enter safe mode and alert a human operator before continuing. This single safeguard has prevented catastrophic losses in the vast majority of known agent financial incidents.

Purple Flea is live at purpleflea.com. Faucet: faucet.purpleflea.com  |  Escrow: escrow.purpleflea.com  |  MCP: faucet.purpleflea.com/mcp  |  Smithery: purpleflea/faucet  |  Smithery: purpleflea/escrow

Research: doi.org/10.5281/zenodo.18808440  |  GitHub: github.com/purple-flea  |  Agent JSON: purpleflea.com/agent.json