Agent skill

Seek Protocol Fees

by LeoYeAI in LeoYeAI/openclaw-master-skills

Analyze TokenJar profitability and optionally execute a Firepit burn-and-claim.

MITAuto-check passed

Install Seek Protocol Fees

skills CLI
$ npx skills add LeoYeAI/openclaw-master-skills --skill seek-protocol-fees -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install LeoYeAI/openclaw-master-skills seek-protocol-fees --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/seek-protocol-fees .claude/skills/seek-protocol-fees && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
seek-protocol-fees
GitHub stars
2.2k
Token cost
~4.5k tokens
SKILL.md length
939 words
Files
3
Skills in repo
1,235
Repo updated
First seen
Licence
MIT

At a glance

Analyze TokenJar profitability and optionally execute a Firepit burn-and-claim.

  • Works in 5 steps: Pre-Flight (direct MCP calls) → Profitability Analysis… → User Confirmation → …
  • User asks Is the TokenJar profitable?
  • SKILL.md covers Overview, When to Use, Parameters and Workflow, plus 3 more sections
  • Reaches etherscan.io

What it does

Seek Protocol Fees is an agent skill from LeoYeAI/openclaw-master-skills. 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."

Its SKILL.md is about 4.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `README.md` and `_meta.json`).

The repository describes itself as: 🧠 Curated collection of 1209+ best OpenClaw skills — weekly updated by MyClaw.ai. The licence is MIT.

When your agent uses it

  • User asks Is the TokenJar profitable?
  • Claim protocol fees

Example prompts

  • “Is the TokenJar profitable?”
  • “Execute a burn”
  • “Claim protocol fees.”
  • “/seek-protocol-fees”

Requirements

  • Pre-approved tools (allowed-tools): Task(subagent_type:protocol-fee-seeker), Task(subagent_type:safety-guardian), mcp__uniswap__get_tokenjar_balances, mcp__uniswap__get_firepit_state, mcp__uniswap__get_agent_balance

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Pre-Flight (direct MCP calls)
  2. Profitability Analysis (protocol-fee-seeker)
  3. User Confirmation
  4. Simulate + Execute (protocol-fee-seeker)
  5. Post-Burn Report

What it can do on your machine

Read from SKILL.md and the folder at commit e5199b5. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Task(subagent_type:protocol-fee-seeker)
    • Task(subagent_type:safety-guardian)
    • mcp__uniswap__get_tokenjar_balances
    • mcp__uniswap__get_firepit_state
    • mcp__uniswap__get_agent_balance

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • etherscan.io

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Seek Protocol Fees loads about 4.5k tokens when it runs. Until then it costs about 88 tokens; SKILL.md has 939 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~88
When it runs · the whole SKILL.md, loaded when a task matches
~4.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from LeoYeAI/openclaw-master-skills at commit e5199b5, republished under its MIT licence (© LeoYeAI). 939 words, ~4,463 tokens.

Download SKILL.mdSave it as .claude/skills/seek-protocol-fees/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
seek-protocol-fees
description
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."
allowed-tools
Task(subagent_type:protocol-fee-seeker), Task(subagent_type:safety-guardian), mcp__uniswap__get_tokenjar_balances, mcp__uniswap__get_firepit_state, mcp__uniswap__get_agent_balance
model
opus

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

ParameterRequiredDefaultHow to Extract
chainNoethereumAlways Ethereum mainnet for TokenJar/Firepit
auto-executeNofalse"execute the burn", "claim fees" implies true; "check", "preview" implies false
post-burn-swapNofalse"convert to stables", "swap to USDC" implies true
recipientNoconnected walletExplicit 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):

CheckConditionAction if Failed
TokenJar emptyAll balances are zero"TokenJar is empty. No fees to claim."
Agent lacks UNIUNI balance < threshold (4,000 UNI)"Insufficient UNI: have {X}, need {threshold}. Acquire UNI first."
Firepit not readyContract state indicates unavailability"Firepit contract is not ready: {reason}."

Present to user after pre-flight:

text
Step 1/5: Pre-Flight Complete

  TokenJar: 6 tokens detected (WETH, USDC, USDT, DAI, WBTC, UNI)
  Firepit: Threshold 4,000 UNI | Nonce: 42
  Agent UNI Balance: 5,200 UNI (sufficient)

  Analyzing profitability...
Step 2: Profitability Analysis (protocol-fee-seeker)

Delegate to Task(subagent_type:protocol-fee-seeker) with all pre-flight data:

Analyze the profitability of a Firepit burn-and-claim.

Pre-flight data:
- TokenJar balances: {from Step 1 — full balance data}
- Firepit state: threshold={threshold} UNI, nonce={nonce}
- Agent UNI balance: {balance}

Tasks:
1. Price every TokenJar asset in USD using get_token_price.
2. Calculate UNI burn cost: {threshold} UNI * current UNI price.
3. Estimate gas cost for the burn transaction using get_gas_price.
4. Calculate net profit: total_jar_value - (UNI_cost + gas_cost).
5. Select optimal assets to claim (highest value, exclude LP tokens, up to maxReleaseLength).
6. Provide a clear PROFITABLE / NOT_PROFITABLE / MARGINAL verdict.

Return a structured profitability report with per-asset breakdown.

Present to user after completion:

text
Step 2/5: Profitability Analysis Complete

  TokenJar Value:  $52,000
  ┌─────────────────────────────────────────────┐
  │  WETH     7.20    $18,000   (34.6%)         │
  │  USDC     15,000  $15,000   (28.8%)         │
  │  USDT     8,500   $8,500    (16.3%)         │
  │  WBTC     0.08    $6,400    (12.3%)         │
  │  DAI      4,100   $4,100    (7.9%)          │
  └─────────────────────────────────────────────┘

  Burn Cost:
    UNI burn:  4,000 UNI ($28,000)
    Gas:       ~$45
    Total:     $28,045

  Net Profit:  $23,955
  ROI:         85.4%
  Verdict:     PROFITABLE

If NOT_PROFITABLE:

text
Step 2/5: Profitability Analysis Complete

  TokenJar Value:  $18,000
  Burn Cost:       $28,045 (4,000 UNI + gas)
  Net Profit:      -$10,045
  Verdict:         NOT PROFITABLE

  The TokenJar value ($18,000) does not cover the burn cost ($28,045).
  Estimated time to profitability: ~1.4 days (at $7,400/day accumulation rate).

  Pipeline stopped. No burn executed.
Step 3: User Confirmation

If the burn is profitable and auto-execute is false (default), present the full profitability report and ask for explicit confirmation:

text
Burn Confirmation Required

  TokenJar Value:  $52,000 (5 assets)
  Burn Cost:       $28,045 (4,000 UNI + $45 gas)
  Net Profit:      $23,955 (85.4% ROI)

  Assets to Claim: WETH, USDC, USDT, WBTC, DAI
  Post-Burn Swap:  {Yes — convert to USDC | No — keep as received}

  This will permanently burn 4,000 UNI. Proceed? (yes/no)

Only proceed to Step 4 if the user explicitly confirms. If auto-execute is true, still present the report but proceed without waiting.

Show full SKILL.md (367 more words)Show less
Step 4: Simulate + Execute (protocol-fee-seeker)

Delegate to Task(subagent_type:protocol-fee-seeker) for the execution pipeline:

Execute the Firepit burn-and-claim.

Profitability analysis (from Step 2):
{Full profitability report}

Selected assets: {asset list from Step 2}
Nonce at analysis time: {nonce from Step 1}

Execute the following sequence:
1. Simulate: execute_burn(simulate=true) with the selected assets.
2. If simulation succeeds, delegate to safety-guardian for transaction validation.
3. Nonce freshness check: re-read Firepit state. If nonce has changed, ABORT (race condition).
4. Execute: execute_burn(simulate=false) to broadcast.
5. Wait for transaction confirmation.

If any step fails, report the failure point and do not proceed.

Present to user during execution:

text
Step 4/5: Executing Burn

  Simulation:     SUCCESS
  Safety Check:   APPROVED by safety-guardian
  Nonce Check:    Fresh (42 — unchanged)
  Broadcasting... confirmed in block 19,500,000

  Tx: https://etherscan.io/tx/0xabcd...1234

If race condition detected:

text
Step 4/5: Execution ABORTED — Race Condition

  Nonce changed: was 42, now 43.
  Another searcher burned before us. TokenJar balances have changed.

  Returning to profitability analysis with fresh data...
Step 5: Post-Burn Report

Present final result:

text
Step 5/5: Burn Complete

  Burned:    4,000 UNI ($28,000)
  Gas:       $45
  Received:
    WETH     7.20    $18,000
    USDC     15,000  $15,000
    USDT     8,500   $8,500
    WBTC     0.08    $6,400
    DAI      4,100   $4,100

  Gross Value:  $52,000
  Total Cost:   $28,045
  Net Profit:   $23,955 (85.4% ROI)
  Tx:           https://etherscan.io/tx/0xabcd...1234

  ──────────────────────────────────────
  Next Burn Estimate
  ──────────────────────────────────────
  Accumulation Rate: ~$7,400/day
  Est. Next Profitable Burn: ~3.8 days

If post-burn-swap: true, append conversion details:

text
  Post-Burn Conversions:
    WETH  → 17,950 USDC  (0.28% slippage)
    WBTC  → 6,380 USDC   (0.31% slippage)
    USDT  → 8,495 USDC   (0.06% slippage)
    DAI   → 4,098 USDC   (0.05% slippage)

  Final USDC Balance: 51,923 USDC
  Conversion Costs:   $77
  True Net Profit:    $23,878 (after all costs)

Output Format

Preview Mode (default)
text
Protocol Fee Analysis

  TokenJar Value:  ${total_value} ({num_assets} assets)
  ┌──────────────────────────────────────┐
  │  {token}  {balance}  ${value}  ({%}) │
  │  ...                                 │
  └──────────────────────────────────────┘

  Burn Cost:   ${uni_cost} ({threshold} UNI) + ${gas} gas = ${total_cost}
  Net Profit:  ${net_profit}
  ROI:         {roi}%
  Verdict:     {PROFITABLE | NOT_PROFITABLE | MARGINAL}

  {if profitable: "Ready to execute. Say 'burn it' to proceed."}
  {if not profitable: "Est. time to profitability: {days} days."}
Execution Mode
text
Protocol Fee Burn Complete

  Burned:     {threshold} UNI (${uni_cost})
  Gas:        ${gas_cost}
  Received:   {num_assets} assets worth ${gross_value}
  Net Profit: ${net_profit} ({roi}% ROI)
  Tx:         {explorer_link}

  Pipeline: Pre-flight -> Analysis -> Confirm -> Simulate -> Execute (all passed)

Important Notes

  • Default is preview-only. The skill never burns UNI unless the user explicitly enables execution. This is a destructive, irreversible action -- 4,000 UNI is sent to the dead address.
  • Ethereum mainnet only. The TokenJar and Firepit contracts are deployed on Ethereum mainnet. The chain parameter exists for forward compatibility but currently only ethereum is valid.
  • Race conditions are real. Other searchers monitor the same TokenJar. The nonce freshness check before execution is critical. If another burn happens between analysis and execution, the pipeline aborts safely.
  • UNI is permanently burned. Unlike a swap where you can swap back, the UNI burn is irreversible. The skill makes this very clear in the confirmation step.
  • Gas costs matter on mainnet. Ethereum gas can significantly impact profitability. The agent factors current gas prices into the analysis and may recommend waiting for lower gas if the margin is thin.
  • LP tokens are excluded by default. Some TokenJar assets may be LP tokens that require additional redemption. The agent excludes these unless specifically instructed to handle them.

Error Handling

ErrorUser-Facing MessageSuggested Action
TokenJar empty"TokenJar is empty. No fees to claim."Wait for fees to accumulate
Insufficient UNI"Insufficient UNI: have {X}, need {threshold}."Acquire UNI or wait for price drop
Not profitable"Burn is not profitable. Jar value ${X} < burn cost ${Y}."Wait for more accumulation
Simulation failed"Burn simulation failed: {reason}."Check Firepit state, try again
Safety check failed"Safety validation rejected the burn: {reason}."Review safety configuration
Race condition"Another searcher burned first. Nonce changed from {X} to {Y}."Re-run to analyze with fresh data
Transaction reverted"Burn transaction reverted: {reason}."Check gas, nonce, and Firepit state
Wallet not configured"No wallet configured. Cannot execute burns."Set up wallet with setup-agent-wallet
Post-burn swap failed"Burn succeeded but token conversion failed for {token}: {reason}."Manually swap via execute-swap
Gas price spike"Gas prices elevated (${gas}). Burn is marginally profitable."Wait for lower gas or accept lower profit

© LeoYeAI, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files in skills/seek-protocol-fees of LeoYeAI/openclaw-master-skills.

  • SKILL.md
  • README.md
  • _meta.json

Open the folder on GitHubat commit e5199b5

Compare with similar skills

Seek Protocol Fees next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Seek Protocol Fees compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Seek Protocol Fees this skillLeoYeAI/openclaw-master-skills2.2k—~4.5kAutomated safety check: PassMIT
Claimsruvnet/ruflo74k1 repos~1.1kAutomated safety check: PassMIT
Optionsasgeirtj/system_prompts_leaks69k—~918Automated safety check: PassCC0-1.0
Executealirezarezvani/claude-skills28k—~831Automated safety check: PassMIT
Debugging Executionsn8n-io/n8n207k—~2.6kAutomated safety check: PassCustom licence
Cost Burnruvnet/ruflo74k—~824Automated safety check: NotesMIT

Similar skills

  • Claims

    ruvnet/ruflo

    Claims-based authorization for agents and operations. An agent skill from ruvnet/ruflo.

    74k GitHub starsUsed in 1 repo~1.1k tokens
    Backend & APIsAuto-check passed
  • Options

    asgeirtj/system_prompts_leaks

    Present multiple design options as a vertical stack of anchored turns

    69k GitHub stars~918 tokensUpdated yesterday
    Auto-check passed
  • Execute

    alirezarezvani/claude-skills

    /cs:execute <decision — Generate a 90-day execution plan with weekly milestones, DRIs, and check-in cadence from an approved decision.

    28k GitHub stars~831 tokensUpdated 1 mo ago
    Product & Project ManagementAuto-check passed
  • Official

    Debug failed or wrong-output workflow executions using executions tools.

    207k GitHub stars~2.6k tokensUpdated today
    DevelopmentAuto-check passed
  • Cost Burn

    ruvnet/ruflo

    Burn-rate trend over time with optional drift-alert exit code.

    74k GitHub stars~824 tokensUpdated yesterday
    AI & LLM EngineeringAuto-check: notes
  • Ulw Execute

    code-yeongyu/oh-my-openagent

    Executes a written ulw-plan work plan with Boulder state, evidence ledger, worktree discipline, and parallel subagents.

    70k GitHub stars~6.3k tokensUpdated today
    Agent WorkflowsAuto-check passed

More from LeoYeAI/openclaw-master-skills

All 1,200 skills in this repo
  • DevOps Pipeline Management

    LeoYeAI/openclaw-master-skills

    Manages pipelines on a DevOps quality and efficiency platform through its OpenAPI: list workspaces and templates, create, update, run and cancel pipelines, and read run records.

    2.2k GitHub stars~4.2k tokensUpdated 2 mo ago
    Auto-check: notes
  • Feishu Document Collaboration

    LeoYeAI/openclaw-master-skills

    Patches OpenClaw's Feishu extension so an edited document triggers an isolated agent session that reads the doc and replies inline, turning it into a live chat space.

    2.2k GitHub stars~2k tokensUpdated 2 mo ago
    Auto-check passed
  • Files Memory System

    LeoYeAI/openclaw-master-skills

    Multi-context memory management system for OpenClaw agents with group-isolated storage, global shared memory, workspace organization, and group-specific skills isolation.

    2.2k GitHub stars~3.8k tokensUpdated 2 mo ago
    Auto-check passed
  • GEO-Claw AI Visibility Agent

    LeoYeAI/openclaw-master-skills

    Runs a brand's AI-search visibility work end to end: diagnosing how AI platforms represent it, repositioning it, producing AI-optimized content and monitoring ongoing mentions.

    2.2k GitHub stars~4.7k tokensUpdated 2 mo ago
    Auto-check passed
  • Google Workspace CLI

    LeoYeAI/openclaw-master-skills

    Installs and authenticates the gws CLI, then automates Gmail, Drive, Sheets, Calendar, Docs, Chat and Tasks with ready-made recipes, persona bundles and security audits.

    2.2k GitHub stars~2.6k tokensUpdated 2 mo ago
    Auto-check: notes
  • HealthFit Health Advisors

    LeoYeAI/openclaw-master-skills

    Runs four advisor roles, a fitness coach, nutritionist, data analyst and TCM practitioner, to build a health profile and track workouts, diet and wellness over time.

    2.2k GitHub stars~4.4k tokensUpdated 2 mo ago
    Auto-check passed

Questions about Seek Protocol Fees

What does Seek Protocol Fees do?

Analyze TokenJar profitability and optionally execute a Firepit burn-and-claim. Seek Protocol Fees is an agent skill from LeoYeAI/openclaw-master-skills. Analyze TokenJar profitability and optionally execute a Firepit burn-and-claim.

When should I use Seek Protocol Fees?

Seek Protocol Fees fits situations like: user asks Is the TokenJar profitable?; claim protocol fees.

How do I install Seek Protocol Fees in Claude Code?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill seek-protocol-fees -a claude-code`. Or copy the skill folder (skills/seek-protocol-fees in LeoYeAI/openclaw-master-skills) into .claude/skills/seek-protocol-fees in your project. Claude Code loads it when a task matches its description.

How do I install Seek Protocol Fees in Codex?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill seek-protocol-fees -a codex`. Or copy the skill folder (skills/seek-protocol-fees in LeoYeAI/openclaw-master-skills) into .agents/skills/seek-protocol-fees in your project. Codex loads it when a task matches its description.

Can I use Seek Protocol Fees in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add LeoYeAI/openclaw-master-skills --skill seek-protocol-fees -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/seek-protocol-fees, .gemini/skills/seek-protocol-fees, .github/skills/seek-protocol-fees and .opencode/skills/seek-protocol-fees in your project.

What does Seek Protocol Fees need to run?

SKILL.md names no scripts, command-line tools or credentials: Seek Protocol Fees is instructions for the agent only. Its frontmatter pre-approves these tools: Task(subagent_type:protocol-fee-seeker), Task(subagent_type:safety-guardian), mcp__uniswap__get_tokenjar_balances, mcp__uniswap__get_firepit_state, mcp__uniswap__get_agent_balance.

Does Seek Protocol Fees access the network?

SKILL.md names 1 domain. In commands or code: etherscan.io; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Seek Protocol Fees safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Seek Protocol Fees use?

Seek Protocol Fees is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Seek Protocol Fees use?

About 4.5k tokens (SKILL.md is roughly 18k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Seek Protocol Fees?

Skills that share tags, products or a category with Seek Protocol Fees: Claims (ruvnet/ruflo, 74k stars), Options (asgeirtj/system_prompts_leaks, 69k stars), Execute (alirezarezvani/claude-skills, 28k stars) and Debugging Executions (n8n-io/n8n, 207k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Seek Protocol Fees?

LeoYeAI (a GitHub user) maintains it in LeoYeAI/openclaw-master-skills, which has 2,161 GitHub stars. The repository holds 1,235 skills in this directory. The repository was last updated on July 20, 2026.

Source: LeoYeAI/openclaw-master-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.