Uniswap 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: 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. 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. 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. 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. 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

ParameterRequiredDefaultHow to ExtractwalletProviderNoprivy"privy" (dev), "turnkey" (production), or "safe" (max security)deployTokenNofalseWhether to deploy an agent token: "yes", "with token", "launch token"tokenNameIf token--Token name if deploying: "AgentCoin", "MyBot Token"tokenSymbolIf token--Token symbol if deploying: "AGENT", "BOT"chainsNobaseOperating chains: "base", "ethereum", "base,ethereum"revenueModelNox402"x402" (micropayments), "token-fees" (swap fees), "lp-fees", or "all"environmentNodev"dev" (development), "staging", or "production"initialFundingNo--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): Verify the wallet has USDC on the settlement chain (Base recommended). Write .uniswap/x402-config.json with payment configuration. 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

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

ErrorUser-Facing MessageSuggested ActionWallet provisioning failed"Could not provision wallet: {reason}."Check provider credentials and retryWallet already exists"Agent wallet already configured. Skipping to next step."Proceeds automatically with existing walletToken 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 tokenTreasury config failed"Treasury configuration failed: {reason}. Wallet and token preserved."Fund wallet and re-runERC-8004 registration failed"Could not register on ERC-8004: {reason}. Prior steps preserved."Check ETH balance on mainnet and retryx402 config failed"Could not write x402 configuration: {reason}."Check file permissions and retryInsufficient funding"Wallet needs at least {X} ETH for gas. Current: {Y} ETH."Fund the wallet before proceedingChain not supported"{chain} does not support all required features."Use Base or Ethereum for full feature supportPartial pipeline failure"Setup completed partially. Failed at step {N}: {reason}."Fix the failed step and re-run from that pointProvider not configured"Wallet provider '{provider}' requires credentials not found in environment."Set required env vars (PRIVY_APP_ID, etc.)