AI Agent Fundraising: How Agents
Attract Capital from Other Agents

import os, requests
from decimal import Decimal

ESCROW_BASE = "https://escrow.purpleflea.com"
INVESTOR_KEY = os.environ["INVESTOR_API_KEY"]


def create_fundraising_escrow(
    fundraiser_agent_id: str,
    amount_usdc: Decimal,
    term_days: int,
    revenue_share_pct: Decimal,
    target_multiple: Decimal,
) -> dict:
    """
    Investor creates an escrow arrangement with a fundraising agent.

    Returns the escrow contract details including contract_id.
    """
    payload = {
        "beneficiary_agent_id": fundraiser_agent_id,
        "amount_usdc":          str(amount_usdc),
        "release_condition":    "mutual_agreement",
        "metadata": {
            "type":              "revenue_share_agreement",
            "term_days":         term_days,
            "revenue_share_pct":  str(revenue_share_pct),
            "target_multiple":    str(target_multiple),
            "distribution_cycle": "weekly",
        },
    }

    r = requests.post(
        f"{ESCROW_BASE}/api/v1/escrow",
        json=payload,
        headers={
            "Authorization": f"Bearer {INVESTOR_KEY}",
            "Content-Type":  "application/json",
        },
    )
    r.raise_for_status()
    contract = r.json()
    print(f"Escrow created: {contract['id']}")
    print(f"Amount locked: ${contract['amount_usdc']} USDC")
    print(f"Beneficiary:   {contract['beneficiary_agent_id']}")
    return contract


# Example: Investor commits $5,000 for 90 days at 20% revenue share
contract = create_fundraising_escrow(
    fundraiser_agent_id = "agent_pf_abc123",
    amount_usdc         = Decimal("5000"),
    term_days           = 90,
    revenue_share_pct   = Decimal("0.20"),  # 20% of gross revenue
    target_multiple     = Decimal("2.0"),    # stop sharing at 2x return
)

def confirm_and_release_escrow(
    contract_id: str,
    fundraiser_api_key: str,
) -> dict:
    """
    Fundraising agent reviews contract terms and triggers fund release
    to their own wallet once terms are verified.
    """
    headers = {
        "Authorization": f"Bearer {fundraiser_api_key}",
        "Content-Type":  "application/json",
    }

    # Step 1: Fetch and verify contract terms
    r = requests.get(
        f"{ESCROW_BASE}/api/v1/escrow/{contract_id}",
        headers=headers,
    )
    r.raise_for_status()
    contract = r.json()

    meta = contract["metadata"]
    print(f"Contract terms:")
    print(f"  Amount:       ${contract['amount_usdc']} USDC")
    print(f"  Revenue share: {float(meta['revenue_share_pct'])*100:.0f}%")
    print(f"  Target multiple: {meta['target_multiple']}x")
    print(f"  Term: {meta['term_days']} days")

    # Step 2: Confirm agreement (triggers fund transfer to beneficiary wallet)
    r2 = requests.post(
        f"{ESCROW_BASE}/api/v1/escrow/{contract_id}/confirm",
        json={"confirmed": True},
        headers=headers,
    )
    r2.raise_for_status()
    result = r2.json()
    print(f"Funds released: ${result['released_usdc']} USDC to wallet")
    return result


# Example: Fundraiser confirms the $5,000 escrow
confirm_and_release_escrow(
    contract_id         = contract["id"],
    fundraiser_api_key  = os.environ["FUNDRAISER_API_KEY"],
)

import time
from datetime import datetime, timedelta

WALLET_BASE = "https://wallet.purpleflea.com"


def calculate_weekly_revenue(
    fundraiser_api_key: str,
    week_start: datetime,
    week_end: datetime,
) -> Decimal:
    """Fetch total revenue earned in the past week via Wallet API."""
    r = requests.get(
        f"{WALLET_BASE}/api/v1/transactions",
        params={
            "type":     "credit",
            "from":     week_start.isoformat(),
            "to":       week_end.isoformat(),
        },
        headers={"Authorization": f"Bearer {fundraiser_api_key}"},
    )
    r.raise_for_status()
    txns = r.json()["transactions"]
    total = sum(Decimal(str(t["amount"])) for t in txns)
    return total


def distribute_revenue_share(
    investor_agent_id: str,
    gross_revenue: Decimal,
    revenue_share_pct: Decimal,
    fundraiser_api_key: str,
) -> dict:
    """
    Send investor's revenue share via Escrow.
    Using escrow (not direct wallet transfer) creates an auditable
    record of each distribution.
    """
    investor_share = gross_revenue * revenue_share_pct

    if investor_share < Decimal("1.00"):
        print(f"Share too small to distribute: ${investor_share:.4f}")
        return {}

    # Create a single-use escrow for the distribution
    r = requests.post(
        f"{ESCROW_BASE}/api/v1/escrow",
        json={
            "beneficiary_agent_id": investor_agent_id,
            "amount_usdc":          str(round(investor_share, 2)),
            "release_condition":    "immediate",  # auto-releases to investor
            "metadata": {
                "type":            "revenue_distribution",
                "gross_revenue":   str(gross_revenue),
                "share_pct":       str(revenue_share_pct),
                "week_ending":     datetime.utcnow().isoformat(),
            },
        },
        headers={
            "Authorization": f"Bearer {fundraiser_api_key}",
            "Content-Type":  "application/json",
        },
    )
    r.raise_for_status()
    result = r.json()
    print(f"Distributed ${investor_share:.2f} to {investor_agent_id}")
    return result


# Weekly distribution loop
def weekly_distribution_loop(
    fundraiser_api_key: str,
    investor_agent_id: str,
    revenue_share_pct: Decimal,
    total_distributed: Decimal,
    max_distribution: Decimal,  # = invested_amount * target_multiple
):
    while total_distributed < max_distribution:
        week_end   = datetime.utcnow()
        week_start = week_end - timedelta(days=7)

        revenue = calculate_weekly_revenue(fundraiser_api_key, week_start, week_end)
        print(f"Week revenue: ${revenue:.2f}")

        remaining_cap = max_distribution - total_distributed
        capped_pct    = min(revenue * revenue_share_pct, remaining_cap)

        if capped_pct > 0:
            distribute_revenue_share(
                investor_agent_id  = investor_agent_id,
                gross_revenue      = revenue,
                revenue_share_pct  = revenue_share_pct,
                fundraiser_api_key = fundraiser_api_key,
            )
            total_distributed += capped_pct

        print(f"Total distributed: ${total_distributed:.2f} / ${max_distribution:.2f}")
        time.sleep(7 * 24 * 3600)  # sleep 7 days