seek-protocol-fees

Analyze TokenJar profitability and optionally execute a Firepit burn-and-claim. Autonomous pipeline: checks balances, prices assets, calculates profit vs. 4,000 UNI burn cost, simulates, and executes if profitable. Default is preview-only. Use when user asks "Is the TokenJar profitable?", "Execute a burn", or "Claim protocol fees."

# Seek Protocol Fees

## Overview

This is the autonomous burn-and-claim pipeline for Uniswap's protocol fee system. The TokenJar (`0xf38521f130fcCF29dB1961597bc5d2B60F995f85`) accumulates fees from V2, V3, V4, UniswapX, and Unichain. The Firepit (`0x0D5Cd355e2aBEB8fb1552F56c965B867346d6721`) allows anyone to burn 4,000 UNI to release those accumulated assets. When the jar's value exceeds the burn cost plus gas, a profit opportunity exists.

This skill runs the full pipeline in one command: check balances, price assets, calculate profitability, simulate the burn, and -- only if the user explicitly opts in -- execute it.

**Why this is 10x better than calling tools individually:**

1. **9-step workflow compressed to one command**: Without this skill, a user must manually check TokenJar balances, price each token in USD, check the Firepit threshold, calculate UNI burn cost at current prices, estimate gas, determine net profitability, select optimal assets, simulate the burn, and finally execute. This skill does all of it with compound context flowing between each step.
2. **Safety-gated execution**: Default mode is preview-only (`auto-execute: false`). Even when execution is enabled, the pipeline simulates first, validates through `safety-guardian`, and checks nonce freshness for race conditions -- protections that are easy to skip when calling tools manually.
3. **Profitability dashboard**: The output is a structured profitability report, not raw JSON from 6 different tools. You see gross value, burn cost, gas cost, net profit, ROI, and per-asset breakdown in one view.
4. **Post-burn conversion**: Optionally converts received tokens to stablecoins in the same pipeline, calculating the true net profit after conversion slippage.

## When to Use

Activate when the user says anything like:

- "Is the TokenJar profitable to burn?"
- "Check protocol fee profitability"
- "Execute a Firepit burn"
- "Burn UNI and claim protocol fees"
- "How much is in the TokenJar? Is it worth burning?"
- "Claim fees from the TokenJar"
- "Seek protocol fees"
- "Run the burn-and-claim pipeline"

**Do NOT use** when the user just wants to monitor accumulation over time (use `monitor-tokenjar` instead) or wants historical burn analysis (use `analyze-burn-economics` instead).

## Parameters

| Parameter      | Required | Default          | How to Extract                                                        |
| -------------- | -------- | ---------------- | --------------------------------------------------------------------- |
| chain          | No       | ethereum         | Always Ethereum mainnet for TokenJar/Firepit                          |
| auto-execute   | No       | false            | "execute the burn", "claim fees" implies true; "check", "preview" implies false |
| post-burn-swap | No       | false            | "convert to stables", "swap to USDC" implies true                     |
| recipient      | No       | connected wallet | Explicit address if provided, otherwise agent's wallet                |

If the user's intent is ambiguous between preview and execution, **default to preview** and present the profitability report. Let the user explicitly confirm before any UNI is burned.

## Workflow

```
                        SEEK-PROTOCOL-FEES PIPELINE
  ┌─────────────────────────────────────────────────────────────────────┐
  │                                                                     │
  │  Step 1: PRE-FLIGHT (direct MCP calls)                              │
  │  ├── get_tokenjar_balances — what's in the jar?                     │
  │  ├── get_firepit_state — threshold, nonce, readiness                │
  │  ├── get_agent_balance — does agent have enough UNI?                │
  │  └── Gate: if jar empty or no UNI → STOP immediately               │
  │          │                                                          │
  │          ▼ (all pre-flight data feeds into Step 2)                  │
  │                                                                     │
  │  Step 2: PROFITABILITY ANALYSIS (protocol-fee-seeker)               │
  │  ├── Price all TokenJar assets in USD                               │
  │  ├── Calculate: burn cost + gas cost vs. jar value                  │
  │  ├── Select optimal assets to claim                                 │
  │  ├── Determine net profit and ROI                                   │
  │  └── Output: Profitability Report                                   │
  │          │                                                          │
  │          ▼ PROFITABILITY GATE                                       │
  │  ┌───────────────────────────────────────────────────┐              │
  │  │  PROFITABLE     → Present report, proceed         │              │
  │  │  NOT PROFITABLE → Present report, STOP            │              │
  │  │  MARGINAL       → Present report, warn user       │              │
  │  └───────────────────────────────────────────────────┘              │
  │          │ (only if profitable)                                     │
  │          ▼                                                          │
  │                                                                     │
  │  Step 3: USER CONFIRMATION                                          │
  │  ├── If auto-execute: false → present report, ask user              │
  │  ├── If auto-execute: true → present report, proceed                │
  │  └── User must explicitly confirm before UNI is burned              │
  │          │                                                          │
  │          ▼                                                          │
  │                                                                     │
  │  Step 4: SIMULATE + EXECUTE (protocol-fee-seeker)                   │
  │  ├── execute_burn(simulate=true) — dry run                          │
  │  ├── safety-guardian validates transaction                          │
  │  ├── Nonce freshness check (race condition protection)              │
  │  ├── execute_burn(simulate=false) — broadcast                       │
  │  └── Wait for confirmation                                          │
  │          │                                                          │
  │          ▼                                                          │
  │                                                                     │
  │  Step 5: POST-BURN REPORT                                           │
  │  ├── Show received tokens with USD values                           │
  │  ├── If post-burn-swap: convert to stablecoins                      │
  │  ├── Calculate final net profit after all costs                     │
  │  └── Recommend next burn timing                                     │
  │                                                                     │
  └─────────────────────────────────────────────────────────────────────┘
```

### Step 1: Pre-Flight (direct MCP calls)

Make three parallel MCP calls to quickly assess feasibility before invoking the agent:

1. Call `mcp__uniswap__get_tokenjar_balances` to get current jar contents.
2. Call `mcp__uniswap__get_firepit_state` to get threshold, nonce, and wallet readiness.
3. Call `mcp__uniswap__get_agent_balance` to check the agent's UNI balance.

**Gate checks** (stop immediately if any fail):

| Check                        | Condition                                   | Action if Failed                                                    |
| ---------------------------- | ------------------------------------------- | ------------------------------------------------------------------- |
| TokenJar empty               | All balances are zero                       | "TokenJar is empty. No fees to claim."                              |
| Agent lacks UNI              | UNI balance < threshold (4,000 UNI)         | "Insufficient UNI: have {X}, need {threshold}. Acquire UNI first." |
| Firepit not ready            | Contract state indicates una