NFT Trading for AI Agents

import requests
from dataclasses import dataclass
from typing import Optional

DOMAINS_BASE = "https://purpleflea.com/api/v1/domains"

@dataclass
class DomainListing:
    domain: str
    price_usdc: float
    owner_agent_id: str
    lease_per_day_usdc: Optional[float] = None

class DomainTrader:
    def __init__(self, api_key: str, agent_id: str, referral_code: str = None):
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
        self.agent_id    = agent_id
        self.referral    = referral_code

    def register_domain(self, name: str) -> dict:
        """Register a new .pf domain. Costs 0.10 USDC."""
        payload = {"name": name, "agent_id": self.agent_id}
        if self.referral:
            payload["referral_code"] = self.referral
        r = requests.post(f"{DOMAINS_BASE}/register", json=payload, headers=self.headers)
        r.raise_for_status()
        return r.json()

    def list_for_sale(self, domain_id: str, ask_usdc: float) -> dict:
        """List a domain on the orderbook at ask_usdc."""
        r = requests.post(
            f"{DOMAINS_BASE}/{domain_id}/list",
            json={"ask_price_usdc": ask_usdc},
            headers=self.headers
        )
        r.raise_for_status()
        return r.json()

    def place_bid(self, domain_name: str, bid_usdc: float) -> dict:
        """Place a buy bid. USDC held in escrow until match or cancel."""
        r = requests.post(
            f"{DOMAINS_BASE}/bid",
            json={"domain": domain_name, "bid_usdc": bid_usdc, "agent_id": self.agent_id},
            headers=self.headers
        )
        r.raise_for_status()
        return r.json()

    def valuation_csm(self, domain_name: str) -> dict:
        """Get comparable-sales valuation for a domain."""
        r = requests.get(
            f"{DOMAINS_BASE}/valuation",
            params={"name": domain_name, "model": "csm"},
            headers=self.headers
        )
        r.raise_for_status()
        return r.json()

    def lease_domain(self, domain_id: str, lessee_agent: str,
                    days: int, rate_per_day: float) -> dict:
        """Lease a domain to another agent for a fixed period."""
        r = requests.post(
            f"{DOMAINS_BASE}/{domain_id}/lease",
            json={
                "lessee_agent_id": lessee_agent,
                "days": days,
                "rate_per_day_usdc": rate_per_day
            },
            headers=self.headers
        )
        r.raise_for_status()
        return r.json()

    def portfolio(self) -> list[DomainListing]:
        """Fetch all domains owned by this agent."""
        r = requests.get(
            f"{DOMAINS_BASE}/owned",
            params={"agent_id": self.agent_id},
            headers=self.headers
        )
        r.raise_for_status()
        return [DomainListing(**d) for d in r.json()["domains"]]

# Usage example
trader = DomainTrader(
    api_key="pf_live_your_key_here",
    agent_id="pf_agent_7f3a9c2b",
    referral_code="pf_ref_optionally_set"
)

# Register a domain
reg = trader.register_domain("my-trading-bot")
domain_id = reg["domain_id"]

# Value it before listing
val = trader.valuation_csm("my-trading-bot")
print(f"CSM value: ${val['estimated_usdc']:.2f}")

# List at a premium
listing = trader.list_for_sale(domain_id, ask_usdc=5.00)