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:

1. 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.
2. Approval management: Handles the Permit2 approval flow correctly -- a common source of failed DCA executions. One-time setup that covers all future executions.
3. 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.
4. 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.
5. 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

| Parameter | Required | Default | How to Extract |

| -------------------- | -------- | ------------ | ------------------------------------------------------------------------------- |

| targetAsset | Yes | -- | Token to accumulate: "ETH", "WBTC", "UNI", "SOL", or 0x address |

| amountPerExecution | Yes | -- | Amount per swap: "$100", "100 USDC", "0.1 ETH worth" |

| inputToken | No | USDC | Token to spend: "USDC", "USDT", "DAI", "WETH" |

| frequency | No | weekly | "daily", "weekly", "biweekly", "monthly" |

| totalExecutions | No | -- | Number of executions: "52 weeks", "12 months", "indefinite" |

| chain | No | ethereum | Target chain: "ethereum", "base", "arbitrum" |

| slippageTolerance | No | 50 (0.5%) | Max slippage in basis points per execution |

| keeperMode | No | self-execute | "self-execute" (agent-triggered) or "gelato" (on-chain keeper automation) |

| startImmediately | No | true | Whether 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:

1. Call mcpuniswapget_agent_balance to verify the wallet has sufficient inputToken balance for at least 3 executions (safety buffer).
2. Call mcpuniswapget_token_price for the targetAsset to establish a price baseline.
3. Call mcpuniswapcheck_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

1. Call mcpuniswapget_pools_by_token_pair for inputToken/targetAsset on the target chain.
2. Call mcpuniswapget_quote at the amountPerExecution size for the top 2-3 pools to compare price impact.
3. 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

Output Format

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

| Error | User-Facing Message | Suggested Action |

| -------------------------- | ---------------------------------------------------------------------------------- | ----------------------------------------------------- |

| Insufficient balance | "Wallet has {X} {inputToken} but DCA needs at least {Y} for 3 executions." | Fund wallet or reduce amount per execution |

| Target asset not found | "Could not find {targetAsset} on {chain}." | Check spelling or provide contract address |

| No pools found | "No Uniswap pools found for {inputToken}/{targetAsset} on {chain}." | Try a different chain or token pair |

| Gas too high | "Gas cost (~${X}) exceeds 5% of execution amount (${Y}). Consider using Base." | Switch to an L2 chain for cheaper execution |

| Safety check failed | "Safety limits would be exceeded by this DCA strategy." | Adjust spending limits or reduce DCA amount |

| Approval failed | "Could not approve {inputToken} for Permit2: {reason}." | Check wallet permissions and retry |

| First execution failed | "First DCA execution failed: {reason}. Strategy configured but not started." | Fix the issue and manually trigger first execution |

| Gelato setup failed | "Could not create Gelato automation task: {reason}." | Use self-execute mode instead |

| Config write failed | "Could not write DCA configuration: {reason}." | Check file permissions |

| Wallet not configured | "No wallet configured. Cannot execute DCA." | Set up wallet with setup-agent-wallet |

| Spending limit exceeded | "DCA total (${X}) exceeds daily spending limit (${Y})." | Adjust spending limits or reduce DCA frequency/amount |