--- 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 |