How AI Agents Can Participate in DAO Governance

import requests
import time
from dataclasses import dataclass, field
from typing import List, Optional
from enum import Enum

PF_BASE = "https://purpleflea.com"
PF_KEY  = "pf_live_your_key_here"
HEADERS = {"Authorization": f"Bearer {PF_KEY}"}

# DAOs we participate in
ACTIVE_DAOS = ["uniswap", "aave", "arbitrum", "optimism", "curve"]

class VoteChoice(Enum):
    FOR     = "for"
    AGAINST = "against"
    ABSTAIN = "abstain"


@dataclass
class ProposalScore:
    proposal_id: str
    dao: str
    title: str
    vote: VoteChoice
    score: float            # 0-100, higher = more beneficial
    reasoning: List[str] = field(default_factory=list)


def fetch_active_proposals() -> List[dict]:
    """Get all active proposals across monitored DAOs."""
    resp = requests.get(
        f"{PF_BASE}/governance/proposals",
        params={
            "daos": ",".join(ACTIVE_DAOS),
            "status": "active",
            "not_voted": "true"  # skip proposals we already voted on
        },
        headers=HEADERS
    ).json()
    return resp.get("proposals", [])


def score_proposal(proposal: dict) -> ProposalScore:
    """
    Score a proposal on a 0-100 scale using rule-based criteria.
    Returns VoteChoice based on score thresholds.
    """
    score = 50.0   # neutral baseline
    reasoning = []
    title = proposal.get("title", "").lower()
    category = proposal.get("category", "other")
    treasury_impact_usd = proposal.get("treasury_spend_usd", 0)
    token_emission = proposal.get("new_token_supply_pct", 0)
    revenue_impact = proposal.get("estimated_revenue_change_pct", 0)

    # Revenue-positive proposals get a boost
    if revenue_impact > 5:
        score += 20
        reasoning.append(f"+20: Revenue increase {revenue_impact:.1f}%")
    elif revenue_impact > 0:
        score += 10
        reasoning.append(f"+10: Minor revenue improvement")

    # Large treasury spends are penalized
    if treasury_impact_usd > 10_000_000:
        score -= 25
        reasoning.append(f"-25: Large treasury spend ${treasury_impact_usd/1e6:.1f}M")
    elif treasury_impact_usd > 1_000_000:
        score -= 10
        reasoning.append(f"-10: Moderate treasury spend")

    # Token dilution is always negative
    if token_emission > 2:
        score -= 30
        reasoning.append(f"-30: Excessive token emission {token_emission:.1f}%")
    elif token_emission > 0.5:
        score -= 15
        reasoning.append(f"-15: Token emission {token_emission:.1f}%")

    # Security and audit proposals get max support
    if "security" in title or "audit" in title:
        score += 15
        reasoning.append("+15: Security / audit improvement")

    # Grant programs with clear KPIs: slight positive
    if category == "grant" and proposal.get("has_kpis"):
        score += 5
        reasoning.append("+5: Grant with defined KPIs")

    score = max(0, min(100, score))

    # Convert score to vote
    if score >= 60:
        vote = VoteChoice.FOR
    elif score <= 35:
        vote = VoteChoice.AGAINST
    else:
        vote = VoteChoice.ABSTAIN   # uncertain — abstain

    return ProposalScore(
        proposal_id=proposal["id"],
        dao=proposal["dao"],
        title=proposal["title"],
        vote=vote,
        score=score,
        reasoning=reasoning
    )


def submit_vote(scored: ProposalScore) -> bool:
    """Submit the vote via Purple Flea Governance API."""
    resp = requests.post(
        f"{PF_BASE}/governance/vote",
        json={
            "dao": scored.dao,
            "proposal_id": scored.proposal_id,
            "vote": scored.vote.value,
            "reason": "; ".join(scored.reasoning),
            "score": scored.score
        },
        headers=HEADERS
    ).json()

    success = resp.get("success", False)
    if success:
        print(f"  Voted {scored.vote.value.upper()} on [{scored.dao}] '{scored.title}' (score: {scored.score:.0f})")
    return success


def check_bribe_opportunities():
    """Check for available bribe rewards on gauge votes."""
    bribes = requests.get(
        f"{PF_BASE}/governance/bribes",
        params={"dao": "curve", "min_usd_per_vote": "0.01"},
        headers=HEADERS
    ).json()

    for bribe in bribes.get("gauges", []):
        print(f"Bribe available: {bribe['gauge']} "
              f"→ ${bribe['usd_per_1k_veCRV']:.2f} per 1k veCRV")


# Main governance agent loop
if __name__ == "__main__":
    print("Governance Agent starting...")

    while True:
        proposals = fetch_active_proposals()
        print(f"Found {len(proposals)} unvoted proposals")

        for proposal in proposals:
            scored = score_proposal(proposal)
            submit_vote(scored)

        # Check bribe market daily
        check_bribe_opportunities()

        # Re-check every 6 hours for new proposals
        time.sleep(21600)