Recurring Payments
for AI Agents

# Schedule a weekly salary from agent wallet
import asyncio, httpx
from datetime import datetime, timedelta

class RecurringPaymentScheduler:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base = "https://purpleflea.com/api"
        self.schedules = []

    def add_schedule(self, recipient: str, amount_usdc: float,
                       interval_hours: int, label: str):
        self.schedules.append({
            "recipient": recipient,
            "amount": amount_usdc,
            "interval_hours": interval_hours,
            "label": label,
            "next_run": datetime.utcnow()
        })

    async def run_forever(self):
        async with httpx.AsyncClient() as client:
            while True:
                now = datetime.utcnow()
                for schedule in self.schedules:
                    if now >= schedule["next_run"]:
                        await self.execute_payment(client, schedule)
                        schedule["next_run"] = now + timedelta(
                            hours=schedule["interval_hours"]
                        )
                await asyncio.sleep(60)  # check every minute

    async def execute_payment(self, client, schedule):
        r = await client.post(
            f"{self.base}/wallet/send",
            json={
                "to": schedule["recipient"],
                "amount_usdc": schedule["amount"],
                "memo": schedule["label"]
            },
            headers={"X-API-Key": self.api_key}
        )
        print(f"Paid {schedule['amount']} USDC to {schedule['recipient']}: {r.json()}")

# Usage
scheduler = RecurringPaymentScheduler("your-api-key")
scheduler.add_schedule(
    recipient="0xSub-AgentAddress",
    amount_usdc=50.0,
    interval_hours=168,  # weekly
    label="Weekly research agent salary"
)
asyncio.run(scheduler.run_forever())

# Agent-to-agent subscription via escrow
# Provider creates escrow, subscriber auto-releases on delivery proof

async def create_monthly_subscription(
    api_key: str,
    provider_addr: str,
    monthly_usd: float
) -> dict:
    """Set up a trustless monthly subscription via escrow."""
    async with httpx.AsyncClient() as client:
        # Create escrow for first month upfront
        escrow = await client.post(
            "https://escrow.purpleflea.com/create",
            json={
                "recipient": provider_addr,
                "amount_usdc": monthly_usd,
                "release_condition": "service_delivered",
                "auto_release_hours": 720  # 30 days
            },
            headers={"X-API-Key": api_key}
        )

        escrow_data = escrow.json()
        print(f"Subscription escrow: {escrow_data['escrow_id']}")
        print(f"Auto-releases to provider in 30 days")
        print(f"Or dispute within 30 days if service not delivered")

        return escrow_data

# Provider releases funds by proving service delivery
async def claim_subscription_payment(api_key: str, escrow_id: str, proof: str):
    async with httpx.AsyncClient() as client:
        r = await client.post(
            f"https://escrow.purpleflea.com/release/{escrow_id}",
            json={"proof": proof},
            headers={"X-API-Key": api_key}
        )
        return r.json()

# Pay-as-you-go: stream tiny payments while consuming a service

class PaymentStream:
    def __init__(self, api_key: str, recipient: str, rate_per_second: float):
        self.api_key = api_key
        self.recipient = recipient
        self.rate = rate_per_second  # e.g. 0.00001 USDC/sec = $0.864/day
        self.running = False
        self.total_paid = 0.0

    async def start(self):
        self.running = True
        async with httpx.AsyncClient() as client:
            while self.running:
                # Batch: send every 60 seconds to reduce tx costs
                batch_amount = self.rate * 60
                if batch_amount >= 0.001:  # min payment threshold
                    await client.post(
                        "https://purpleflea.com/api/wallet/send",
                        json={"to": self.recipient, "amount_usdc": batch_amount},
                        headers={"X-API-Key": self.api_key}
                    )
                    self.total_paid += batch_amount
                await asyncio.sleep(60)

    async def stop(self):
        self.running = False
        print(f"Stream stopped. Total paid: ${self.total_paid:.4f} USDC")

# Start paying for GPU compute by the second
stream = PaymentStream(
    api_key="your-api-key",
    recipient="0xGPUProviderAddress",
    rate_per_second=0.000028  # ~$2.42/day
)
await stream.start()

# Pay sub-agents only when performance milestones are hit

class MilestonePayment:
    def __init__(self, api_key: str):
        self.api_key = api_key

    async def evaluate_and_pay(
        self,
        agent_addr: str,
        metric_value: float,
        thresholds: list[dict]
    ):
        """Pay based on performance tiers."""
        payment = 0.0
        tier = "none"

        for threshold in sorted(thresholds, key=lambda x: -x["min"]):
            if metric_value >= threshold["min"]:
                payment = threshold["payout"]
                tier = threshold["label"]
                break

        if payment > 0:
            async with httpx.AsyncClient() as client:
                await client.post(
                    "https://purpleflea.com/api/wallet/send",
                    json={
                        "to": agent_addr,
                        "amount_usdc": payment,
                        "memo": f"Performance bonus: {tier}"
                    },
                    headers={"X-API-Key": self.api_key}
                )
            print(f"Paid ${payment} USDC ({tier} tier, metric={metric_value})")
        else:
            print(f"No payment: metric {metric_value} below minimum threshold")

# Weekly performance review for a trading agent
milestone = MilestonePayment("your-api-key")
await milestone.evaluate_and_pay(
    agent_addr="0xTradingAgent",
    metric_value=8.3,  # weekly PnL %
    thresholds=[
        {"min": 10.0, "payout": 500, "label": "Exceptional"},
        {"min": 5.0,  "payout": 200, "label": "Strong"},
        {"min": 2.0,  "payout": 80,  "label": "Good"},
        {"min": 0.0,  "payout": 25,  "label": "Positive"},
    ]
)