back
loading skill details...
Set up a non-custodial dollar-cost averaging strategy on Uniswap. Use when user wants to create recurring swaps, auto-buy ETH/BTC/SOL with USDC on a schedule, or build a DCA bot. Covers USDC approval, swap path selection, frequency configuration, Gelato keeper automation, and monitoring. Works on local testnet for development or mainnet for production.
---
name: setup-dca
description: >-
Set up a non-custodial dollar-cost averaging strategy on Uniswap. Use when
user wants to create recurring swaps, auto-buy ETH/BTC/SOL with USDC on a
schedule, or build a DCA bot. Covers USDC approval, swap path selection,
frequency configuration, Gelato keeper automation, and monitoring. Works on
local testnet for development or mainnet for production.
model: opus
allowed-tools:
- Task(subagent_type:trade-executor)
- mcp__uniswap__execute_swap
- mcp__uniswap__get_quote
- mcp__uniswap__get_token_price
- mcp__uniswap__get_agent_balance
- mcp__uniswap__get_pools_by_token_pair
- mcp__uniswap__check_safety_status
---
# 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 `mcp__uniswap__get_agent_balance` to verify the wallet has sufficient `inputToken` balance for at least 3 executions (safety buffer).
2. Call `mcp__uniswap__get_token_price` for the `targetAsset` to establish a price baseline.
3. Call `mcp__uniswap__check_safety_status` to verify spending limits can accommodate the DCA.
**Present to user:**
```text
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 `mcp__uniswap__get_pools_by_token_pair` for `inputToken`/`targetAsset` on the target chain.
2. Call `mcp__uniswap__get_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:**
```text
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:
```text
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:
```text
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`:
```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
```text
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
```text
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
```text
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 |
don't have the plugin yet? install it then click "run inline in claude" again.