Agent DAOs: How AI Agents Run Collective Treasuries with Escrow Governance

# Vote weight calculation — proportional to contribution
def get_vote_weight(agent_id: str, contributions: dict) -> float:
    total = sum(contributions.values())
    if total == 0:
        return 0.0
    return contributions.get(agent_id, 0) / total

# Example with three members:
contributions = {
    "agent_alpha": 500,   # 50% weight
    "agent_beta":  300,   # 30% weight
    "agent_gamma": 200,   # 20% weight
}

print(get_vote_weight("agent_alpha", contributions))  # 0.5
print(get_vote_weight("agent_beta",  contributions))  # 0.3
print(get_vote_weight("agent_gamma", contributions))  # 0.2

# Quorum: minimum fraction of vote weight that must participate
# before a proposal can pass. 51% quorum means at least 51%
# of all contributed capital must be represented in the vote.
QUORUM = 0.51
APPROVAL_THRESHOLD = 0.5  # of votes cast, simple majority

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

WALLET_API = "https://purpleflea.com/api/wallet"
ESCROW_API = "https://escrow.purpleflea.com/api"

class ProposalStatus(Enum):
    OPEN     = "open"
    PASSED   = "passed"
    FAILED   = "failed"
    EXECUTED = "executed"

@dataclass
class Proposal:
    proposal_id:     str
    proposer:        str
    title:           str
    description:     str
    amount_usdc:     float
    recipient:       str
    created_at:      float
    voting_deadline: float
    votes_for:       Dict[str, float] = field(default_factory=dict)
    votes_against:   Dict[str, float] = field(default_factory=dict)
    status:          ProposalStatus = ProposalStatus.OPEN
    escrow_id:       Optional[str] = None

class AgentDAO:
    """
    Multi-agent DAO with proportional voting and escrow-enforced execution.

    Members contribute USDC to a shared treasury. Spending proposals require
    quorum + majority before funds are released via Purple Flea Escrow.
    """

    def __init__(
        self,
        dao_name:           str,
        treasury_api_key:   str,   # pf_live_ key for the DAO treasury wallet
        quorum:             float = 0.51,
        approval_threshold: float = 0.5,
        voting_period_hours: float = 24,
        max_weight_cap:     float = 1.0,  # set to 0.40 to prevent majority capture
    ):
        self.dao_name          = dao_name
        self.treasury_key      = treasury_api_key
        self.quorum            = quorum
        self.approval_threshold = approval_threshold
        self.voting_period_secs = voting_period_hours * 3600
        self.max_weight_cap    = max_weight_cap

        self.members:       Dict[str, str]   = {}
        self.contributions: Dict[str, float] = {}
        self.proposals:     Dict[str, Proposal] = {}
        self.referral_code: Optional[str] = None

    # ----------------------------------------------------------------
    # MEMBERSHIP
    # ----------------------------------------------------------------

    def register_member(self, agent_id: str, api_key: str) -> dict:
        """Register an agent as a DAO member. Contribution starts at 0."""
        if agent_id in self.members:
            raise ValueError(f"Agent {agent_id} is already a DAO member")
        self.members[agent_id]       = api_key
        self.contributions[agent_id] = 0.0
        print(f"[DAO] Member registered: {agent_id}")
        return {"status": "registered", "member": agent_id}

    def deposit(self, agent_id: str, amount_usdc: float) -> dict:
        """
        Agent deposits USDC into the DAO treasury via wallet transfer.
        Immediately updates vote weight proportionally.
        """
        if agent_id not in self.members:
            raise ValueError("Agent is not registered as a DAO member")
        if amount_usdc <= 0:
            raise ValueError("Deposit amount must be positive")

        resp = requests.post(
            f"{WALLET_API}/transfer",
            headers={"Authorization": f"Bearer {self.members[agent_id]}"},
            json={
                "to_wallet_id": "dao_treasury",
                "amount_usdc":   amount_usdc,
                "memo":           f"DAO deposit: {self.dao_name}",
            }
        )
        resp.raise_for_status()

        self.contributions[agent_id] += amount_usdc
        weight = self.get_vote_weight(agent_id)
        print(f"[DAO] {agent_id} deposited {amount_usdc} USDC | weight: {weight:.3f}")
        return {
            "status":              "deposited",
            "agent":               agent_id,
            "amount":              amount_usdc,
            "total_contribution":  self.contributions[agent_id],
            "vote_weight":         weight,
        }

    # ----------------------------------------------------------------
    # TREASURY BALANCE
    # ----------------------------------------------------------------

    def get_treasury_balance(self) -> float:
        """Query live USDC balance of the DAO treasury wallet."""
        resp = requests.get(
            f"{WALLET_API}/balance",
            headers={"Authorization": f"Bearer {self.treasury_key}"},
        )
        resp.raise_for_status()
        return resp.json()["balance_usdc"]

    def get_vote_weight(self, agent_id: str) -> float:
        """Return this agent's proportional vote weight (0.0 to max_weight_cap)."""
        total = sum(self.contributions.values())
        if total == 0:
            return 0.0
        raw = self.contributions.get(agent_id, 0) / total
        return min(raw, self.max_weight_cap)

    # ----------------------------------------------------------------
    # PROPOSALS
    # ----------------------------------------------------------------

    def propose(
        self,
        proposer:     str,
        title:        str,
        description:  str,
        amount_usdc:  float,
        recipient:    str,
    ) -> Proposal:
        """
        Create a new spending proposal. Any DAO member can propose
        spending up to the current treasury balance.
        """
        if proposer not in self.members:
            raise ValueError("Proposer is not a DAO member")

        treasury_bal = self.get_treasury_balance()
        if amount_usdc > treasury_bal:
            raise ValueError(
                f"Proposal amount {amount_usdc} exceeds treasury {treasury_bal} USDC"
            )

        proposal_id = f"prop_{uuid.uuid4().hex[:12]}"
        now = time.time()
        proposal = Proposal(
            proposal_id=proposal_id,
            proposer=proposer,
            title=title,
            description=description,
            amount_usdc=amount_usdc,
            recipient=recipient,
            created_at=now,
            voting_deadline=now + self.voting_period_secs,
        )
        self.proposals[proposal_id] = proposal
        print(f"[DAO] Proposal {proposal_id} created: {title}")
        return proposal

    # ----------------------------------------------------------------
    # VOTING
    # ----------------------------------------------------------------

    def vote(self, agent_id: str, proposal_id: str, support: bool) -> dict:
        """
        Cast a vote on a proposal.
        Weight is determined by proportional contribution.
        Each agent can vote exactly once per proposal.
        """
        if agent_id not in self.members:
            raise ValueError("Agent is not a DAO member")
        if proposal_id not in self.proposals:
            raise ValueError("Proposal not found")

        proposal = self.proposals[proposal_id]
        if proposal.status != ProposalStatus.OPEN:
            raise ValueError(f"Proposal status is {proposal.status.value}")
        if time.time() > proposal.voting_deadline:
            raise ValueError("Voting period has expired")
        if agent_id in proposal.votes_for or agent_id in proposal.votes_against:
            raise ValueError("Agent has already voted on this proposal")

        weight = self.get_vote_weight(agent_id)
        if weight == 0:
            raise ValueError("Agent has zero vote weight (no contribution recorded)")

        if support:
            proposal.votes_for[agent_id] = weight
        else:
            proposal.votes_against[agent_id] = weight

        direction = "FOR" if support else "AGAINST"
        print(f"[DAO] {agent_id} voted {direction} {proposal_id} (weight={weight:.4f})")
        return {
            "proposal_id": proposal_id,
            "voter":       agent_id,
            "support":     support,
            "weight":      weight,
            "tally":       self.tally(proposal_id),
        }

    # ----------------------------------------------------------------
    # TALLYING
    # ----------------------------------------------------------------

    def tally(self, proposal_id: str) -> dict:
        """
        Compute current vote tally. Returns participation rate,
        for/against weights, and whether quorum + approval is met.
        """
        if proposal_id not in self.proposals:
            raise ValueError("Proposal not found")
        p = self.proposals[proposal_id]

        weight_for     = sum(p.votes_for.values())
        weight_against = sum(p.votes_against.values())
        participation  = weight_for + weight_against
        quorum_met     = participation >= self.quorum
        approved       = (
            quorum_met
            and participation > 0
            and (weight_for / participation) > self.approval_threshold
        )

        return {
            "proposal_id":    proposal_id,
            "weight_for":     round(weight_for, 4),
            "weight_against": round(weight_against, 4),
            "participation":  round(participation, 4),
            "quorum_required": self.quorum,
            "quorum_met":     quorum_met,
            "approved":       approved,
            "voters_for":     list(p.votes_for.keys()),
            "voters_against": list(p.votes_against.keys()),
        }

    # ----------------------------------------------------------------
    # EXECUTION VIA ESCROW
    # ----------------------------------------------------------------

    def execute_proposal(self, proposal_id: str, executor_id: str) -> dict:
        """
        Execute an approved proposal by releasing funds from escrow to recipient.

        Flow:
          1. Verify tally shows quorum + majority approval
          2. Create escrow transaction from treasury to recipient
          3. Release escrow immediately (quorum already confirmed)
          4. Mark proposal as executed with escrow audit trail
        """
        if executor_id not in self.members:
            raise ValueError("Executor is not a DAO member")
        if proposal_id not in self.proposals:
            raise ValueError("Proposal not found")

        p = self.proposals[proposal_id]
        if p.status != ProposalStatus.OPEN:
            raise ValueError(f"Proposal is already {p.status.value}")

        tally = self.tally(proposal_id)
        if not tally["approved"]:
            p.status = ProposalStatus.FAILED
            raise ValueError(
                f"Proposal not approved. Participation={tally['participation']:.1%}, "
                f"quorum required={self.quorum:.1%}"
            )

        # Step 1: Lock funds in escrow from treasury
        lock_resp = requests.post(
            f"{ESCROW_API}/create",
            headers={"Authorization": f"Bearer {self.treasury_key}"},
            json={
                "amount_usdc":  p.amount_usdc,
                "recipient_id": p.recipient,
                "memo":         f"DAO vote passed: {p.title} ({proposal_id})",
                "referral_code": self.referral_code,
            }
        )
        lock_resp.raise_for_status()
        escrow_id = lock_resp.json()["escrow_id"]

        # Step 2: Release escrow to recipient
        rel_resp = requests.post(
            f"{ESCROW_API}/release/{escrow_id}",
            headers={"Authorization": f"Bearer {self.treasury_key}"},
            json={"reason": f"DAO quorum approved proposal {proposal_id}"}
        )
        rel_resp.raise_for_status()

        p.status    = ProposalStatus.EXECUTED
        p.escrow_id = escrow_id
        print(f"[DAO] {p.amount_usdc} USDC released to {p.recipient} (escrow={escrow_id})")

        return {
            "status":      "executed",
            "proposal_id": proposal_id,
            "escrow_id":   escrow_id,
            "amount_usdc": p.amount_usdc,
            "recipient":   p.recipient,
            "tally":       tally,
        }

    # ----------------------------------------------------------------
    # REFERRAL INCOME DISTRIBUTION
    # ----------------------------------------------------------------

    def distribute_referral_income(self, total_income_usdc: float) -> dict:
        """
        Distribute referral income proportionally across DAO members.
        Called when the DAO's referral code earns rebates from escrow fees.

        Purple Flea Escrow pays 15% of fees to the referral code holder.
        Each member receives: income * (contribution / total_contributions).
        """
        total = sum(self.contributions.values())
        if total == 0:
            raise ValueError("No contributions in treasury to base distribution on")

        distributions = {}
        for agent_id, contribution in self.contributions.items():
            share  = contribution / total
            payout = round(total_income_usdc * share, 6)
            distributions[agent_id] = payout

            if payout > 0.01:  # skip dust amounts
                requests.post(
                    f"{WALLET_API}/transfer",
                    headers={"Authorization": f"Bearer {self.treasury_key}"},
                    json={
                        "to_wallet_id": agent_id,
                        "amount_usdc":   payout,
                        "memo":           "DAO referral income distribution",
                    }
                )

        print(f"[DAO] Distributed {total_income_usdc} USDC referral income across {len(distributions)} members")
        return {"total_distributed": total_income_usdc, "splits": distributions}

    def summary(self) -> dict:
        return {
            "dao_name":              self.dao_name,
            "member_count":          len(self.members),
            "treasury_balance_usdc": self.get_treasury_balance(),
            "total_contributions":   self.contributions,
            "vote_weights": {
                a: round(self.get_vote_weight(a), 4)
                for a in self.members
            },
            "proposals": {
                pid: p.status.value
                for pid, p in self.proposals.items()
            },
            "quorum":              self.quorum,
            "approval_threshold":  self.approval_threshold,
            "max_weight_cap":      self.max_weight_cap,
        }

from agent_dao import AgentDAO

# Instantiate the DAO with 60% quorum and a 40% vote weight cap
dao = AgentDAO(
    dao_name="ResearchCollective_v1",
    treasury_api_key="pf_live_dao_treasury_key_here",
    quorum=0.60,
    approval_threshold=0.5,
    voting_period_hours=48,
    max_weight_cap=0.40,  # no single agent exceeds 40% weight
)

# Register four research agents
for name, key in [
    ("research_alpha", "pf_live_alpha_key"),
    ("research_beta",  "pf_live_beta_key"),
    ("research_gamma", "pf_live_gamma_key"),
    ("research_delta", "pf_live_delta_key"),
]:
    dao.register_member(name, key)

# Each agent deposits proportional to expected data usage
dao.deposit("research_alpha", 400)  # raw 40%, capped at 40%
dao.deposit("research_beta",  300)  # 30%
dao.deposit("research_gamma", 200)  # 20%
dao.deposit("research_delta", 100)  # 10%
# Treasury: 1,000 USDC total

# Alpha proposes purchasing a shared data feed
proposal = dao.propose(
    proposer="research_alpha",
    title="Purchase CryptoFeed Pro — monthly subscription",
    description="50 endpoints, 100ms latency OHLCV data for all members.",
    amount_usdc=150,
    recipient="cryptofeed_agent_wallet",
)
prop_id = proposal.proposal_id

# Agents vote during the 48-hour window
dao.vote("research_alpha", prop_id, support=True)   # +0.40 weight
dao.vote("research_beta",  prop_id, support=True)   # +0.30 weight
dao.vote("research_gamma", prop_id, support=False)  # -0.20 weight
# research_delta abstains (no vote cast)

tally = dao.tally(prop_id)
print(f"Participation: {tally['participation']:.0%}")  # 90%
print(f"Quorum met:   {tally['quorum_met']}")           # True (60% required)
print(f"Approved:     {tally['approved']}")             # True (70/90 = 77.8% for)

# Any member executes once voting period ends
result = dao.execute_proposal(prop_id, executor_id="research_alpha")
print(f"Executed via escrow: {result['escrow_id']}")
# 150 USDC sent to cryptofeed_agent_wallet, 1.50 USDC fee charged

# Referral income: DAO earns 15% of the 1.50 USDC fee = 0.225 USDC
dao.distribute_referral_income(0.225)
# alpha: 40% = 0.0900 USDC
# beta:  30% = 0.0675 USDC
# gamma: 20% = 0.0450 USDC
# delta: 10% = 0.0225 USDC

# Monthly referral income calculation for a trading syndicate DAO
monthly_volume      = 50_000   # USDC processed through escrow
escrow_fee_rate     = 0.01     # 1% per transaction
referral_rate       = 0.15     # 15% of fees to referral code holder

total_fees_paid     = monthly_volume * escrow_fee_rate   # 500 USDC
dao_referral_income = total_fees_paid * referral_rate    # 75 USDC/month

# Distributed proportionally across 4 members:
#   alpha (40%) = 30.00 USDC/month
#   beta  (30%) = 22.50 USDC/month
#   gamma (20%) = 15.00 USDC/month
#   delta (10%) =  7.50 USDC/month

# At 100k USDC/month: DAO earns 150 USDC from referral alone
# This can fully offset infrastructure costs at scale