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 agents)
- Initial funding: {initialFunding} (or 2x estimated gas need)

This wallet will be used for:
- Token deployment (if enabled)
- Treasury management (fee conversion, LP)
- x402 payment settlement
- General agent operations

Configure appropriate spending policies for a self-funding agent.

Present to user after completion:

Step 1/5: Wallet Provisioned

  Address:    0xABCD...1234
  Provider:   Privy (development)
  Chain:      Base (8453)
  Funded:     0.05 ETH ($98.00)
  Policies:   $10,000/day, Router + Permit2 approved

  Proceeding to token deployment...

If wallet already exists, detect it via mcp__uniswap__get_agent_balance and skip to Step 2:

Step 1/5: Wallet Already Configured (skipped)

  Address:    0xABCD...1234
  Balance:    0.12 ETH + 500 USDC
  Status:     Active

  Skipping to next step...

Step 2: Token Deployment (Optional)

Only execute if deployToken=true. Otherwise, skip to Step 3.

Delegate to Task(subagent_type:token-deployer):

Deploy an agent token for self-funding:
- Token name: {tokenName}
- Token symbol: {tokenSymbol}
- Chain: {chains[0]} (primary chain)
- Wallet: {wallet address from Step 1}
- Paired token: WETH
- Hooks: anti-snipe (2-block delay) + revenue-share (5%)
- LP lock: 10 years
- Initial liquidity: {derive from initialFunding or suggest minimum}

This token is part of a self-funding agent setup. The revenue-share hook
directs 5% of swap fees to the agent wallet for treasury management.

Present to user after completion:

Step 2/5: Token Deployed

  Token:      AgentCoin (AGENT)
  Address:    0x5678...efgh
  Chain:      Base (8453)
  Pool:       AGENT/WETH V4 (0.3%, anti-snipe + revenue-share)
  LP Lock:    10 years (unlocks 2036-02-10)
  Revenue:    5% of swap fees -> agent wallet

  Proceeding to treasury management...

If deployToken=false:

Step 2/5: Token Deployment (skipped)

  No token deployment requested.
  Revenue model: {revenueModel} (no token economics)

  Proceeding to treasury management...

Step 3: Treasury Management

Delegate to Task(subagent_type:treasury-manager):

Configure treasury management for a self-funding agent:
- Wallet: {wallet address from Step 1}
- Chains: {chains}
- Action: assess + configure (initial setup, not full operations)

Revenue sources:
{if deployToken: "- Token swap fees (5% revenue share from AGENT/WETH pool)"}
{if revenueModel includes x402: "- x402 micropayments (USDC on Base)"}
{if revenueModel includes lp-fees: "- LP fee earnings"}

Configure:
- Auto-convert non-stablecoin earnings to USDC
- Conversion threshold: $10 minimum
- DCA enabled for large conversions
- Circuit breaker: halt if treasury drops below $100
- Operating reserve: 30 days of estimated burn rate

Present to user after completion:

Step 3/5: Treasury Configured

  Treasury Value: $98.00 (initial funding)
  Auto-Convert:   Enabled (non-stables -> USDC, threshold: $10)
  DCA:            Enabled for conversions > 0.1% pool TVL
  Circuit Breaker: $100 minimum (INACTIVE -- above threshold)
  Burn Rate:      ~$0/day (no operations yet)
  Runway:         Indefinite (no burn rate established)

  Proceeding to identity registration...

Step 4: Identity Registration

Delegate to Task(subagent_type:identity-verifier):

Register this agent on ERC-8004:
- Agent address: {wallet address from Step 1}
- Chain: ethereum (ERC-8004 registries are on mainnet)

Capabilities to register:
{if deployToken: "- Token deployment and pool management"}
{if revenueModel includes x402: "- x402 service provider"}
- Uniswap trading and LP management
- Treasury management

After registration, query the trust tier to confirm.

Present to user after completion:

Step 4/5: Identity Registered

  ERC-8004:    Registered on Identity Registry
  Address:     0xABCD...1234
  Trust Tier:  BASIC (new registration)
  Reputation:  0/100 (initial -- builds with activity)
  Registry Tx: https://etherscan.io/tx/0x...

  Proceeding to payment configuration...

Step 5: Payment Configuration

Configure x402 micropayment acceptance directly (no agent needed):

1. Verify the wallet has USDC on the settlement chain (Base recommended).
2. Write .uniswap/x402-config.json with payment configuration.
3. Write .well-known/x402-manifest.json for service discovery.

Step 5/5: Payments Configured

  Mode:         Accept (x402 micropayments)
  Chain:        Base (8453)
  Wallet:       0xABCD...1234
  Facilitator:  Auto-selected

  Pricing:
    Price quotes:       $0.001/call
    Pool analytics:     $0.003/call
    Route optimization: $0.005/call
    Simulation:         $0.010/call
    Execution:          $0.050/call

  Config Files:
    .uniswap/x402-config.json
    .well-known/x402-manifest.json

Output Format

Full Setup (with token)

Self-Funding Agent Setup Complete

  ══════════════════════════════════════════════
  AGENT IDENTITY CARD
  ══════════════════════════════════════════════

  Wallet:
    Address:     0xABCD...1234
    Provider:    Privy (development)
    Chain:       Base (8453)
    Balance:     0.05 ETH + 0 USDC

  Token:
    Name:        AgentCoin (AGENT)
    Address:     0x5678...efgh
    Pool:        AGENT/WETH V4 (0.3%)
    Hooks:       Anti-snipe + Revenue Share (5%)
    LP Lock:     10 years

  Treasury:
    Auto-Convert: Enabled (-> USDC)
    Circuit Break: $100 minimum
    Burn Rate:    ~$0/day (initial)
    Runway:       Indefinite

  Identity:
    ERC-8004:    Registered (BASIC tier)
    Reputation:  0/100 (builds with activity)
    Registry:    0x7177...09A

  Payments:
    x402:        Accepting micropayments
    Settlement:  USDC on Base
    Pricing:     $0.001 - $0.050 per call

  ══════════════════════════════════════════════

  Pipeline: Wallet -> Token -> Treasury -> Identity -> Payments
  Status:   ALL 5 STEPS COMPLETE

  Next Steps:
    1. Fund the wallet with USDC for x402 pay mode
    2. Share your x402 manifest for service discovery
    3. Start operations to build reputation (rep: 0 -> basic -> verified)
    4. Monitor treasury health with /manage-treasury

Setup Without Token

Self-Funding Agent Setup Complete

  ══════════════════════════════════════════════
  AGENT IDENTITY CARD
  ══════════════════════════════════════════════

  Wallet:
    Address:     0xABCD...1234
    Provider:    Privy (development)
    Chain:       Base (8453)
    Balance:     0.05 ETH

  Token:         Not deployed (service-based revenue model)

  Treasury:
    Auto-Convert: Enabled (-> USDC)
    Circuit Break: $100 minimum
    Revenue:      x402 micropayments

  Identity:
    ERC-8004:    Registered (BASIC tier)
    Reputation:  0/100

  Payments:
    x402:        Accepting micropayments
    Settlement:  USDC on Base

  ══════════════════════════════════════════════

  Pipeline: Wallet -> (Token skipped) -> Treasury -> Identity -> Payments
  Status:   ALL STEPS COMPLETE (4/5, token skipped)

Partial Failure

Self-Funding Agent Setup -- Partial

  Step 1: Wallet       COMPLETE  (0xABCD...1234)
  Step 2: Token        COMPLETE  (AGENT at 0x5678...efgh)
  Step 3: Treasury     FAILED    (Could not configure auto-convert)
  Step 4: Identity     SKIPPED   (depends on Step 3)
  Step 5: Payments     SKIPPED   (depends on Step 4)

  Error at Step 3: "Insufficient USDC balance for initial DCA configuration."

  What's preserved:
    - Wallet is provisioned and funded (Step 1)
    - Token is deployed with pool and locked LP (Step 2)

  To resume:
    1. Fund wallet with USDC: send USDC to 0xABCD...1234
    2. Re-run: "Set up self-funding" (will detect existing wallet + token)

Important Notes

• This is the most complex composite skill. It orchestrates 5 agents sequentially, each feeding context to the next. Expect the full pipeline to take 2-5 minutes depending on chain conditions and whether token deployment is included.
• Token deployment is irreversible. Once a token is deployed and the pool is created, it cannot be undone. The skill simulates everything via safety-guardian before execution, but make sure the token name, symbol, and parameters are correct before confirming.
• The pipeline is resumable. If a step fails, prior steps are preserved. Re-running the skill detects existing wallet and token, skipping completed steps automatically.
• ERC-8004 registration is on Ethereum mainnet. Even if your agent operates on Base, the identity registry is on Ethereum. This requires a small amount of ETH on mainnet for the registration transaction.
• Reputation starts at 0. The initial trust tier is BASIC. Building reputation requires completing trades, providing liquidity, and receiving positive feedback from counterparties. Use the agent actively to progress from basic -> verified -> trusted.
• x402 payments settle on Base by default. Base has ~200ms settlement and low gas costs, making it ideal for micropayments. The wallet must hold USDC on Base to accept payments.
• Revenue model affects treasury configuration. "x402" mode configures for micropayment income. "token-fees" mode configures for swap fee revenue. "lp-fees" mode configures for LP earnings. "all" enables all three.
• Development vs production providers. Privy is recommended for development (fast setup, easy testing). Turnkey or Safe is recommended for production (TEE-backed signing, hardware security). The skill selects based on the environment parameter.

Error Handling

Error	User-Facing Message	Suggested Action
Wallet provisioning failed	"Could not provision wallet: {reason}."	Check provider credentials and retry
Wallet already exists	"Agent wallet already configured. Skipping to next step."	Proceeds automatically with existing wallet
Token deployment failed	"Token deployment failed at step: {reason}. Wallet is preserved."	Fix the issue and re-run (wallet will be reused)
Token already deployed	"Token {symbol} already deployed. Skipping to treasury."	Proceeds automatically with existing token
Treasury config failed	"Treasury configuration failed: {reason}. Wallet and token preserved."	Fund wallet and re-run
ERC-8004 registration failed	"Could not register on ERC-8004: {reason}. Prior steps preserved."	Check ETH balance on mainnet and retry
x402 config failed	"Could not write x402 configuration: {reason}."	Check file permissions and retry
Insufficient funding	"Wallet needs at least {X} ETH for gas. Current: {Y} ETH."	Fund the wallet before proceeding
Chain not supported	"{chain} does not support all required features."	Use Base or Ethereum for full feature support
Partial pipeline failure	"Setup completed partially. Failed at step {N}: {reason}."	Fix the failed step and re-run from that point
Provider not configured	"Wallet provider '{provider}' requires credentials not found in environment."	Set required env vars (PRIVY_APP_ID, etc.)