Uniswap Self Funding Setup

Set up a complete self-funding agent lifecycle in one command. Orchestrates 5 agents to take an agent from zero to self-sustaining: provisions wallet, optionally deploys token with V4 pool, configures treasury management, registers identity on ERC-8004, and sets up x402 micropayments. Use when user wants to make their agent self-funding, earn and manage its own revenue, or configure autonomous agent operations end-to-end.

# Self-Funding Setup

## Overview

The most complex composite skill in the system. Orchestrates 5 specialized agents in sequence to take an agent from zero infrastructure to a fully self-sustaining economic entity -- wallet, optional token, treasury management, on-chain identity, and payment acceptance -- in a single command.

**Why this is 10x better than setting up each component manually:**

1. **5 domains compressed into 1 command**: Wallet provisioning, token deployment, treasury management, identity registration, and payment configuration each require different expertise and tooling. Manually coordinating these takes hours and requires deep knowledge of Privy/Turnkey APIs, Uniswap V4 pool creation, DCA strategies, ERC-8004 registries, and x402 protocol. This skill handles all five.
2. **Context flows between stages**: Each agent receives the output of all prior agents. The treasury-manager knows the wallet address from Step 1 and the token address from Step 2. The identity-verifier registers the wallet from Step 1 with the capabilities demonstrated by Steps 2-3. Without this skill, you'd manually copy-paste addresses and configuration between five separate tools.
3. **Conditional pipeline**: Token deployment (Step 2) is optional -- skip it for agents that earn through services rather than token economics. The skill adapts the remaining steps based on which revenue model is selected.
4. **Rollback awareness**: If Step 3 fails, Steps 1 and 2 are still valid and preserved. The skill reports exactly which steps succeeded and which failed, so you can fix the issue and re-run from the failure point rather than starting over.
5. **Progressive output**: You see each stage complete in real-time with a running summary. By the end, you have a complete "agent identity card" showing every component of the self-funding infrastructure.

## When to Use

Activate when the user says anything like:

- "Set up my agent to be self-funding"
- "Make my agent earn and manage its own revenue"
- "Configure autonomous agent operations end-to-end"
- "I want my agent to be self-sustaining"
- "Set up the full agent economy stack"
- "Bootstrap my agent's financial infrastructure"
- "Create a self-funding agent from scratch"
- "Full agent setup: wallet, token, treasury, identity, payments"

**Do NOT use** when the user only wants one component (use the individual skills: `setup-agent-wallet`, `deploy-agent-token`, `manage-treasury`, `verify-agent`, or `configure-x402` respectively), or when the agent is already partially set up and only needs one missing piece.

## Parameters

| Parameter        | Required | Default | How to Extract                                                          |
| ---------------- | -------- | ------- | ----------------------------------------------------------------------- |
| walletProvider   | No       | privy   | "privy" (dev), "turnkey" (production), or "safe" (max security)         |
| deployToken      | No       | false   | Whether to deploy an agent token: "yes", "with token", "launch token"   |
| tokenName        | If token | --      | Token name if deploying: "AgentCoin", "MyBot Token"                     |
| tokenSymbol      | If token | --      | Token symbol if deploying: "AGENT", "BOT"                               |
| chains           | No       | base    | Operating chains: "base", "ethereum", "base,ethereum"                   |
| revenueModel     | No       | x402    | "x402" (micropayments), "token-fees" (swap fees), "lp-fees", or "all"  |
| environment      | No       | dev     | "dev" (development), "staging", or "production"                         |
| initialFunding   | No       | --      | Initial funding amount: "$100", "0.1 ETH"                              |

If the user says "with token" or "launch a token", set `deployToken=true` and ask for `tokenName` and `tokenSymbol` if not provided.

## Workflow

```
                     SELF-FUNDING SETUP PIPELINE
  ┌──────────────────────────────────────────────────────────────────────┐
  │                                                                      │
  │  Step 1: WALLET PROVISIONING (wallet-provisioner)                    │
  │  ├── Determine provider: privy (dev) / turnkey (prod) / safe (max)   │
  │  ├── Provision wallet with signing capabilities                      │
  │  ├── Configure spending policies                                     │
  │  ├── Fund with gas (2x estimated need)                               │
  │  └── Output: Wallet address, provider, policies                      │
  │          │                                                           │
  │          ▼ wallet address feeds into all subsequent steps             │
  │                                                                      │
  │  Step 2: TOKEN DEPLOYMENT (token-deployer) [OPTIONAL]                │
  │  ├── Deploy ERC-20 token contract                                    │
  │  ├── Create Uniswap V4 pool with anti-snipe hooks                   │
  │  ├── Bootstrap initial liquidity                                     │
  │  ├── Lock LP tokens (10 years default)                               │
  │  └── Output: Token address, pool address, LP position                │
  │          │                                                           │
  │          ▼ token + pool info feeds into treasury config               │
  │                                                                      │
  │  Step 3: TREASURY MANAGEMENT (treasury-manager)                      │
  │  ├── Configure auto-conversion of earned fees to stablecoins         │
  │  ├── Set up DCA strategy for volatile holdings                       │
  │  ├── Configure yield optimization for idle capital                   │
  │  ├── Set circuit breaker thresholds                                  │
  │  └── Output: Treasury config, burn rate, runway projection           │
  │          │                                                           │
  │          ▼ wallet + capabilities feed into identity registration      │
  │                                                                      │
  │  Step 4: IDENTITY REGISTRATION (identity-verifier)                   │
  │  ├── Register agent on ERC-8004 Identity Registry                    │
  │  ├── Set capabilities metadata (trading, LP, services)               │
  │  ├── Initialize reputation score                                     │
  │  └── Output: ERC-8004 identity, trust tier, registry tx              │
  │          │                                                           │
  │          ▼ identity + wallet feed into payment config                 │
  │                                                                      │
  │  Step 5: PAYMENT CONFIGURATION (direct)                              │
  │  ├── Configure x402 micropayment acceptance                          │
  │  ├── Set per-tool pricing                                            │
  │  ├── Generate .well-known/x402-manifest.json                         │
  │  ├── Verify USDC balance for pay mode                                │
  │  └── Output: x402 config, pricing, manifest                          │
  │                                                                      │
  │  ═══════════════════════════════════════════════════════════          │
  │  FINAL: AGENT IDENTITY CARD                                          │
  │  ├── Wallet, token, treasury, identity, payments -- all linked       │
  │  └── Complete self-funding infrastructure report                     │
  │                                                                      │
  └──────────────────────────────────────────────────────────────────────┘
```

### Step 1: Wallet Provisioning

Delegate to `Task(subagent_type:wallet-provisioner)`:

```
Provision an agent wallet for self-funding operations:
- Provider: {walletProvider}
- Chains: {chains}
- Environment: {environment}
- Spending limit: $10,000/day (default for self-funding agen