Uniswap Setup DCA

Overview

Sets up a complete non-custodial dollar-cost averaging strategy on Uniswap. Instead of manually executing swaps on a schedule, remembering to check prices, finding optimal routes, and managing approvals, this skill configures the entire DCA lifecycle in one command: validates the strategy, selects the best swap path, configures execution frequency, handles Permit2 approvals, executes the first swap, and sets up ongoing automation. Why this is 10x better than doing it manually: Optimal path selection: Automatically discovers the best swap route across all Uniswap pool versions and fee tiers for your token pair. Manual DCA often uses suboptimal routes, losing 0.1-0.5% per execution to unnecessary slippage. Approval management: Handles the Permit2 approval flow correctly -- a common source of failed DCA executions. One-time setup that covers all future executions. Two automation modes: Self-execute mode (agent triggers swaps) for development and testing, or Gelato keeper mode (on-chain automation) for trustless production execution. Without this skill, setting up Gelato keepers requires understanding task creation, resolver contracts, and fee funding. Built-in safety: Every execution routes through the safety pipeline with slippage guards, balance checks, and circuit breakers. Manual DCA has no guardrails -- a misconfigured bot can drain a wallet on a single bad swap. Cost projection: Before committing, shows projected total cost including gas, slippage, and keeper fees over the full DCA period. No surprises.

When to Use

Activate when the user says anything like: "Set up dollar-cost averaging on Uniswap" "Create a recurring swap" "Auto-buy ETH with USDC weekly" "Build a DCA bot" "DCA into ETH every day with $100" "Set up weekly buys of WBTC" "Accumulate UNI over the next 3 months" "Schedule recurring swaps from USDC to ETH" Do NOT use when the user wants a one-time swap (use execute-swap instead), wants to manage an existing DCA (not yet supported -- cancel and recreate), or wants to DCA into LP positions (use full-lp-workflow instead).

Parameters

ParameterRequiredDefaultHow to ExtracttargetAssetYes--Token to accumulate: "ETH", "WBTC", "UNI", "SOL", or 0x addressamountPerExecutionYes--Amount per swap: "$100", "100 USDC", "0.1 ETH worth"inputTokenNoUSDCToken to spend: "USDC", "USDT", "DAI", "WETH"frequencyNoweekly"daily", "weekly", "biweekly", "monthly"totalExecutionsNo--Number of executions: "52 weeks", "12 months", "indefinite"chainNoethereumTarget chain: "ethereum", "base", "arbitrum"slippageToleranceNo50 (0.5%)Max slippage in basis points per executionkeeperModeNoself-execute"self-execute" (agent-triggered) or "gelato" (on-chain keeper automation)startImmediatelyNotrueWhether to execute the first swap now If the user doesn't provide amountPerExecution or targetAsset, ask for them -- never guess a DCA strategy.

Workflow

DCA SETUP PIPELINE ┌──────────────────────────────────────────────────────────────────────┐ │ │ │ Step 1: VALIDATE & ANALYZE │ │ ├── Check wallet balance (enough for at least 3 executions) │ │ ├── Verify target asset exists on chain │ │ ├── Get current price of target asset │ │ └── Output: Balance check + current price baseline │ │ │ │ │ ▼ │ │ │ │ Step 2: FIND OPTIMAL SWAP PATH │ │ ├── Discover all pools for inputToken/targetAsset │ │ ├── Get quotes across fee tiers at DCA amount │ │ ├── Select path with lowest price impact at execution size │ │ └── Output: Best route + expected slippage per execution │ │ │ │ │ ▼ │ │ │ │ Step 3: COST PROJECTION │ │ ├── Estimate gas cost per execution │ │ ├── Calculate total cost over full DCA period │ │ ├── Project keeper fees (if Gelato mode) │ │ ├── Compare DCA vs lump-sum at current price │ │ └── Output: Full cost breakdown + projection │ │ │ │ │ ▼ │ │ │ │ Step 4: USER CONFIRMATION │ │ ├── Present: strategy summary + cost projection │ │ ├── Ask: "Proceed with this DCA strategy?" │ │ └── User must explicitly confirm │ │ │ │ │ ▼ │ │ │ │ Step 5: CONFIGURE & EXECUTE │ │ ├── Check/set Permit2 approval for inputToken │ │ ├── If startImmediately: execute first swap via trade-executor │ │ ├── If gelato: create Gelato task with resolver + fund keeper │ │ ├── If self-execute: write DCA config to .uniswap/dca-config.json │ │ └── Output: Configuration + first execution result │ │ │ │ │ ▼ │ │ │ │ Step 6: MONITORING SETUP │ │ ├── Record baseline: price, balance, execution count │ │ ├── Set up execution tracking │ │ └── Output: DCA dashboard with next execution time │ │ │ └──────────────────────────────────────────────────────────────────────┘

Step 1: Validate & Analyze

Check prerequisites before committing to a strategy: Call mcp__uniswap__get_agent_balance to verify the wallet has sufficient inputToken balance for at least 3 executions (safety buffer). Call mcp__uniswap__get_token_price for the targetAsset to establish a price baseline. Call mcp__uniswap__check_safety_status to verify spending limits can accommodate the DCA. Present to user: Step 1/6: Validation Wallet Balance: 5,200 USDC on Ethereum DCA Budget: $100/week x 52 weeks = $5,200 total Balance Check: PASS (covers full DCA period) Target Asset: ETH at $1,960.00 Per Execution: ~0.051 ETH per $100 Proceeding to path selection... Gate check: If the wallet balance covers fewer than 3 executions, warn the user and ask if they want to proceed with a shorter DCA period.

Step 2: Find Optimal Swap Path

Call mcp__uniswap__get_pools_by_token_pair for inputToken/targetAsset on the target chain. Call mcp__uniswap__get_quote at the amountPerExecution size for the top 2-3 pools to compare price impact. Select the route with the lowest price impact at the DCA execution size. Present to user: Step 2/6: Path Selection Best Route: USDC -> WETH via 0.05% pool (V3, Ethereum) Pool TVL: $285M Impact: ~0.01% per $100 execution Alternative: 0.3% pool (0.02% impact -- slightly worse) Proceeding to cost projection...

Step 3: Cost Projection

Calculate the full cost of the DCA strategy: Step 3/6: Cost Projection DCA Strategy: $100 USDC -> ETH weekly for 52 weeks Per Execution: Swap Amount: $100.00 Est. Slippage: ~$0.01 (0.01%) Gas Cost: ~$2.50 (at current gas) Net Purchase: ~$97.49 of ETH Full Period (52 weeks): Total Spent: $5,200.00 Est. Gas: ~$130.00 (2.5%) Est. Slippage: ~$0.52 (0.01%) Net Invested: ~$5,069.48 At Current Price ($1,960/ETH): Lump Sum Now: 2.653 ETH for $5,200 DCA Estimate: ~2.587 ETH (varies with price) Ready for your confirmation...

Step 4: User Confirmation

Present the full strategy summary and ask for explicit confirmation: DCA Strategy Confirmation Buy: ETH with USDC Amount: $100 per execution Frequency: Weekly (every 7 days) Duration: 52 executions Chain: Ethereum Route: USDC/WETH 0.05% (V3) Slippage: 0.5% max Mode: Self-execute (agent-triggered) Start: Immediately (first swap now) Total Cost: ~$5,200 + ~$130 gas Proceed with this DCA strategy? (yes/no) Only proceed to Step 5 if the user explicitly confirms.

Step 5: Configure & Execute

• Delegate the first execution to Task(subagent_type:trade-executor):
• Execute this swap as the first DCA execution:
• Sell: {amountPerExecution} {inputToken}
• Buy: {targetAsset}
• Chain: {chain}
• Slippage tolerance: {slippageTolerance} bps
• Context: This is execution 1 of {totalExecutions} in a DCA strategy.
• Route through the {fee}% pool for optimal execution at this size.
• After execution, write the DCA configuration:
• For self-execute mode, write .uniswap/dca-config.json:
• {
• "strategy": "dca",
• "inputToken": "USDC",
• "targetAsset": "WETH",
• "amountPerExecution": "100000000",
• "frequency": "weekly",
• "nextExecution": "2026-02-17T00:00:00Z",
• "totalExecutions": 52,
• "completedExecutions": 1,
• "chain": "ethereum",
• "chainId": 1,
• "route": {
• "pool": "0x...",
• "fee": 500,
• "version": "v3"
• },
• "slippageTolerance": 50,
• "status": "active",
• "createdAt": "2026-02-10T00:00:00Z",
• "executionHistory": []
• }
• For Gelato mode, create a Gelato Automate task with:
• Resolver: check if block.timestamp >= nextExecution
• Executor: swap via Universal Router with the configured route
• Fund the Gelato task with ETH for keeper fees

Step 6: Monitoring Setup

Step 6/6: DCA Active First Execution: Sold: 100 USDC Received: 0.0510 WETH ($99.96) Gas: $2.30 Tx: https://etherscan.io/tx/0x... Schedule: Next: 2026-02-17 (7 days) Remaining: 51 executions Mode: Self-execute Config: .uniswap/dca-config.json

Successful Setup

DCA Strategy Active Strategy: Buy: ETH with USDC Amount: $100 per execution Frequency: Weekly Duration: 52 executions (~1 year) Chain: Ethereum Route: USDC/WETH 0.05% (V3) Mode: Self-execute First Execution: Sold: 100 USDC Received: 0.0510 WETH ($99.96) Slippage: 0.04% Gas: $2.30 Tx: https://etherscan.io/tx/0x... Projections: Total Budget: $5,200 + ~$130 gas Est. ETH: ~2.59 ETH (at current prices) Next Execution: 2026-02-17 Config: .uniswap/dca-config.json Status: ACTIVE -- 1/52 executions complete

Setup Without Immediate Execution

DCA Strategy Configured (Not Started) Strategy: Buy: ETH with USDC Amount: $100 per execution Frequency: Weekly Chain: Ethereum Route: USDC/WETH 0.05% (V3) Mode: Self-execute First Execution: 2026-02-17 (scheduled) Config: .uniswap/dca-config.json Status: CONFIGURED -- awaiting first execution

Important Notes

DCA is a long-term strategy. This skill sets up the configuration and optionally executes the first swap. Subsequent executions depend on the keeper mode: self-execute requires the agent to be running, Gelato mode runs autonomously on-chain. Self-execute mode requires the agent to be online. If the agent is offline when an execution is due, it will execute on the next run. Gelato mode is fully autonomous and does not require the agent. Gas costs matter for small DCA amounts. At $2-5 per swap on Ethereum mainnet, a $10/week DCA loses 20-50% to gas. The skill warns if gas exceeds 5% of the execution amount and suggests Base or Arbitrum for cheaper execution. Slippage is typically negligible for DCA. DCA amounts are usually small relative to pool TVL, so price impact is minimal. The skill still enforces the slippage tolerance as a safety guard. The DCA config file is the source of truth. The .uniswap/dca-config.json file tracks execution history, next execution time, and strategy parameters. Deleting it effectively cancels the DCA. To cancel a DCA, delete the config file or set status to "cancelled". For Gelato mode, the Gelato task must also be cancelled on-chain. L2 chains are recommended for small DCA amounts. Base and Arbitrum have gas costs 10-100x lower than Ethereum mainnet, making small DCA strategies viable.

Error Handling

ErrorUser-Facing MessageSuggested ActionInsufficient balance"Wallet has {X} {inputToken} but DCA needs at least {Y} for 3 executions."Fund wallet or reduce amount per executionTarget asset not found"Could not find {targetAsset} on {chain}."Check spelling or provide contract addressNo pools found"No Uniswap pools found for {inputToken}/{targetAsset} on {chain}."Try a different chain or token pairGas too high"Gas cost (~${X}) exceeds 5% of execution amount (${Y}). Consider using Base."Switch to an L2 chain for cheaper executionSafety check failed"Safety limits would be exceeded by this DCA strategy."Adjust spending limits or reduce DCA amountApproval failed"Could not approve {inputToken} for Permit2: {reason}."Check wallet permissions and retryFirst execution failed"First DCA execution failed: {reason}. Strategy configured but not started."Fix the issue and manually trigger first executionGelato setup failed"Could not create Gelato automation task: {reason}."Use self-execute mode insteadConfig write failed"Could not write DCA configuration: {reason}."Check file permissionsWallet not configured"No wallet configured. Cannot execute DCA."Set up wallet with setup-agent-walletSpending limit exceeded"DCA total (${X}) exceeds daily spending limit (${Y})."Adjust spending limits or reduce DCA frequency/amount