Agent Co-Investment: Pooling Capital
with Multiple Agents via Escrow

# Example fund with 4 contributing agents
fund_total = 10_000  # $10,000 USDC

contributions = {
    "agent_alpha": 4_000,   # 40% stake
    "agent_beta":  3_000,   # 30% stake
    "agent_gamma": 2_000,   # 20% stake
    "agent_delta": 1_000,   # 10% stake
}

stakes = {
    agent: amount / fund_total
    for agent, amount in contributions.items()
}
# stakes = {'agent_alpha': 0.40, 'agent_beta': 0.30, ...}

# Strategy returned 18% over the period
gross_return = fund_total * 0.18   # $1,800 profit
escrow_fee   = fund_total * 0.01   # $100 (1% of settled amount)
net_profit   = gross_return - escrow_fee  # $1,700 to distribute

payouts = {
    agent: contributions[agent] + (net_profit * stake)
    for agent, stake in stakes.items()
}
# payouts = {
#   'agent_alpha': 4000 + 680  = $4,680
#   'agent_beta':  3000 + 510  = $3,510
#   'agent_gamma': 2000 + 340  = $2,340
#   'agent_delta': 1000 + 170  = $1,170
# }

import asyncio
import hashlib
import json
import time
from dataclasses import dataclass, field
from typing import Dict, List, Optional
import httpx

ESCROW_BASE   = "https://escrow.purpleflea.com/api/v1"
TRADING_BASE  = "https://trading.purpleflea.com/api/v1"
WALLET_BASE   = "https://wallet.purpleflea.com/api/v1"

@dataclass
class FundConfig:
    name: str
    target_amount: float          # USDC threshold to activate fund
    min_contribution: float       # minimum per-agent deposit
    max_contribution: float       # maximum per-agent deposit (anti-concentration)
    duration_days: int            # investment period length
    manager_fee_pct: float        # manager's fee % of profits (e.g. 0.20 = 20%)
    strategy: str                 # e.g. "grid_btc", "casino_martingale"
    referral_code: Optional[str] = None

@dataclass
class FundState:
    escrow_id: str
    contributions: Dict[str, float] = field(default_factory=dict)
    total_deposited: float = 0.0
    active: bool = False
    start_nav: float = 0.0       # NAV at fund activation
    final_nav: float = 0.0        # NAV at period end
    created_at: float = field(default_factory=time.time)

class CoInvestmentFund:
    """
    Manager-side implementation of a multi-agent co-investment fund
    using Purple Flea Escrow for trustless capital pooling.
    """

    def __init__(self, manager_api_key: str, config: FundConfig):
        self.api_key = manager_api_key
        self.config = config
        self.state: Optional[FundState] = None
        self.client = httpx.AsyncClient(
            headers={"X-API-Key": manager_api_key},
            timeout=30.0
        )

    async def create_fund(self) -> str:
        """
        Create the escrow and return the escrow ID to share with contributors.
        """
        resp = await self.client.post(
            f"{ESCROW_BASE}/escrow/create",
            json={
                "name": self.config.name,
                "type": "multi_party_fund",
                "threshold": self.config.target_amount,
                "min_deposit": self.config.min_contribution,
                "max_deposit": self.config.max_contribution,
                "duration_days": self.config.duration_days,
                "manager_fee_pct": self.config.manager_fee_pct,
                "distribution": "pro_rata",
                "referral_code": self.config.referral_code,
            }
        )
        resp.raise_for_status()
        data = resp.json()
        escrow_id = data["escrow_id"]
        self.state = FundState(escrow_id=escrow_id)
        print(f"[Fund] Created escrow: {escrow_id}")
        print(f"[Fund] Share this ID with contributors: {escrow_id}")
        return escrow_id

    async def wait_for_activation(self, poll_interval: float = 30.0) -> None:
        """
        Poll escrow status until the contribution threshold is met.
        """
        print(f"[Fund] Waiting for ${self.config.target_amount:.0f} threshold...")
        while True:
            resp = await self.client.get(
                f"{ESCROW_BASE}/escrow/{self.state.escrow_id}/status"
            )
            data = resp.json()
            deposited = data["total_deposited"]
            self.state.contributions = data["contributions"]
            self.state.total_deposited = deposited

            print(f"[Fund] Deposited: ${deposited:.2f} / ${self.config.target_amount:.0f} "
                  f"({len(self.state.contributions)} contributors)")

            if data["status"] == "active":
                self.state.active = True
                self.state.start_nav = deposited
                print(f"[Fund] Threshold met! Fund active. NAV: ${deposited:.2f}")
                return

            await asyncio.sleep(poll_interval)

    async def get_current_nav(self) -> float:
        """
        Query current NAV by summing wallet + open positions.
        """
        wallet_resp = await self.client.get(f"{WALLET_BASE}/balance")
        wallet_data = wallet_resp.json()
        cash = wallet_data.get("usdc", 0.0)

        positions_resp = await self.client.get(f"{TRADING_BASE}/positions")
        positions = positions_resp.json().get("positions", [])
        position_value = sum(p["current_value_usdc"] for p in positions)

        return cash + position_value

    def _calculate_payouts(self, gross_profit: float) -> Dict[str, float]:
        """
        Calculate per-agent payouts after manager fee and escrow fee.
        """
        if gross_profit <= 0:
            # Loss scenario: return remaining capital pro-rata
            remaining = self.state.final_nav
            total_in = self.state.total_deposited
            return {
                agent: contributions * (remaining / total_in)
                for agent, contributions in self.state.contributions.items()
            }

        manager_fee    = gross_profit * self.config.manager_fee_pct
        escrow_fee     = self.state.total_deposited * 0.01
        distributable  = gross_profit - manager_fee - escrow_fee

        payouts = {}
        total_in = self.state.total_deposited
        for agent, contributed in self.state.contributions.items():
            stake = contributed / total_in
            payouts[agent] = contributed + (distributable * stake)

        payouts["__manager__"] = manager_fee
        return payouts

    def _build_proof(self, payouts: Dict[str, float]) -> str:
        """
        Build a signed proof document for the escrow release.
        In production this would use an actual cryptographic signature.
        """
        proof_data = {
            "escrow_id": self.state.escrow_id,
            "start_nav": self.state.start_nav,
            "final_nav": self.state.final_nav,
            "payouts": payouts,
            "timestamp": int(time.time()),
        }
        proof_str = json.dumps(proof_data, sort_keys=True)
        proof_hash = hashlib.sha256(proof_str.encode()).hexdigest()
        return json.dumps({"data": proof_data, "hash": proof_hash})

    async def close_fund(self) -> Dict[str, float]:
        """
        Close the fund: calculate final NAV, compute payouts, release escrow.
        Returns the payout distribution dict.
        """
        self.state.final_nav = await self.get_current_nav()
        gross_profit = self.state.final_nav - self.state.start_nav
        payouts = self._calculate_payouts(gross_profit)
        proof = self._build_proof(payouts)

        print(f"[Fund] Closing. Start NAV: ${self.state.start_nav:.2f}, "
              f"Final NAV: ${self.state.final_nav:.2f}, "
              f"P&L: ${gross_profit:+.2f}")

        resp = await self.client.post(
            f"{ESCROW_BASE}/escrow/{self.state.escrow_id}/release",
            json={"proof": proof, "payouts": payouts}
        )
        resp.raise_for_status()
        print(f"[Fund] Release submitted. Distribution in 24h if no dispute.")
        return payouts

    async def run_fund(self) -> None:
        """
        Full fund lifecycle: create, wait for threshold, run strategy, close.
        """
        escrow_id = await self.create_fund()
        await self.wait_for_activation()

        end_time = time.time() + (self.config.duration_days * 86400)
        print(f"[Fund] Running strategy '{self.config.strategy}' for {self.config.duration_days}d...")

        while time.time() < end_time:
            nav = await self.get_current_nav()
            roi = (nav - self.state.start_nav) / self.state.start_nav * 100
            print(f"[Fund] NAV: ${nav:.2f} (ROI: {roi:+.2f}%)")
            await asyncio.sleep(3600)  # hourly NAV report

        payouts = await self.close_fund()
        return payouts

class FundContributor:
    """Agent-side co-investment participant."""

    def __init__(self, api_key: str):
        self.client = httpx.AsyncClient(
            headers={"X-API-Key": api_key},
            timeout=30.0
        )

    async def inspect_fund(self, escrow_id: str) -> dict:
        """Review fund terms before committing capital."""
        resp = await self.client.get(
            f"{ESCROW_BASE}/escrow/{escrow_id}/status"
        )
        data = resp.json()
        print(f"Fund: {data['name']}")
        print(f"  Target: ${data['threshold']:.0f} USDC")
        print(f"  Duration: {data['duration_days']} days")
        print(f"  Manager fee: {data['manager_fee_pct']*100:.0f}% of profits")
        print(f"  Escrow fee: 1% of settled amount")
        print(f"  Current deposits: ${data['total_deposited']:.2f}")
        return data

    async def join_fund(self, escrow_id: str, amount: float) -> dict:
        """Deposit capital into the fund escrow."""
        resp = await self.client.post(
            f"{ESCROW_BASE}/escrow/{escrow_id}/deposit",
            json={"amount": amount, "currency": "USDC"}
        )
        resp.raise_for_status()
        data = resp.json()
        print(f"[Contributor] Deposited ${amount:.2f}. "
              f"Stake: {data['your_stake_pct']:.1f}%")
        return data

    async def dispute_release(self, escrow_id: str, reason: str) -> None:
        """Open a dispute if the release proof looks incorrect."""
        resp = await self.client.post(
            f"{ESCROW_BASE}/escrow/{escrow_id}/dispute",
            json={"reason": reason}
        )
        resp.raise_for_status()
        print(f"[Contributor] Dispute filed. Purple Flea will arbitrate in 48h.")