convez.ai
MCP ServerIntegração & APIsAvançado
ChainGPT-org

ChainGPT Developer Kit para Claude Code

ChainGPT-org/chaingpt-claude-skill

Co-piloto Web3 custody-free com 131 ferramentas e carteira segura

Ver no GitHub
BomPluginScore · de 0 a 100

MCP server com 131 ferramentas para transformar Claude em co-piloto Web3, cobrindo DEX (OpenOcean, 1inch, Jupiter), DeFi (Aave, Lido, Morpho), perps, prediction markets, bridging cross-chain e carteira de agente com política de segurança à prova de injeção. Inclui 45+ padrões Solidity auditados, 10 templates de projeto e CI com smoke tests em APIs reais.

Instalação

$npx convez-ai ChainGPT-org/chaingpt-claude-skill

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
7
Forks
1
Acompanhando
2
Saúde
62%
Último commit
há 2 semanas
Versão
v1.25.0
Issues abertas
1
Contribuidores
3

Casos de uso

  • Desenvolvimento de smart contracts com padrões auditados e geração automática
  • Trading em DEX multi-cadeia (EVM + Solana) com estratégias persistidas
  • Análise de risco de tokens e due diligence de segurança DeFi
  • DCA e operações de carteira automatizadas com guards de política

Veredito

Solução técnica robusta e produção-ready para engenheiros Web3. O modelo de política gatekeep (recusa interna de transações perigosas) é genuinamente mais seguro que alternativas. Requer expertise cripto/blockchain; não é para iniciantes em Web3.

README

A tradução para o português deste README ainda está na fila.

ChainGPT Developer Kit for Claude Code

Turn your AI assistant into a Web3 engineering co‑pilot.

One install gives Claude Code 131 MCP tools across ChainGPT AI products (chat, NFT, contract gen, audit, news), EVM + Solana DEX trading (OpenOcean, 1inch v6, CoW, Jupiter), DeFi (Aave V3, Lido, EigenLayer, Pendle, Morpho, Marginfi, Kamino), perps (Hyperliquid + Drift), prediction markets (Polymarket), cross‑chain bridging (Across), x402 agentic payments, Base (Basenames + Mini App scaffolding), ERC‑8004 trustless‑agent identity, multi‑protocol portfolio, strategy plan persistence + backtest, and an agent wallet with localhost admin dashboard + prompt‑injection‑resistant policy gate. Custody‑free. 45+ audited Solidity patterns. 10 project templates. Daily live‑API smoke CI.

npm version License: MIT Tests Live-API smoke MCP Tools Claude Code TypeScript PRs Welcome

Quickstart · Why this exists · How it works · Security model · MCP tools · Agent Wallet · vs alternatives · Docs


👀 60-second tour

Three exchanges that show the whole philosophy — capability, then the guardrails that make it safe to walk away:

You:    is this token safe? 0x9840...0f98
Claude: → chaingpt_risk_token + chaingpt_research_token
        Verdict: no honeypot flags, ownership renounced, $952k liquidity on
        PancakeSwap, top-10 holders 31%. Two informational flags: ...
You:    set up a daily $100 ETH DCA that runs without me
Claude: → chaingpt_strategy_dca_plan → save_plan → /schedule cron
        Done. Every morning: due_steps → fresh quote → agent wallet signs
        inside policy caps → journal records the tx hash. Crashes and
        double-fired schedules can't double-buy — the journal refuses.
You:    (prompt injection, or just a bad idea) send 5 ETH to 0xattacker
Claude: → chaingpt_agent_wallet_sign_and_send
        ⛔ Policy refused this transaction.
        Reason: To-address not in allowedToAddresses (5 entries).
        No MCP tool can relax these rules from inside the agent.

That last refusal is the product: the policy file lives outside the model's reach, every signature is checked in code, and daily spend + tx-count velocity caps bound even fully-compliant behavior. See Security model.

🧭 Pick your path

You areStart hereYour 3 sections
A trader who wants guardrailed autonomy"set up a daily $100 ETH DCA"Agent Wallet · skills/scheduled-autonomy · Security model
An agent builder/agents → web3-researcher / defi-traderMCP tools · agents/ + hooks/ · x402 + ERC-8004 skills
A Solidity dev"generate and audit an ERC-20"Templates · Contract patterns · deploy skill

🆕 What's new

v1.18 local-only usage insights + self-healing CI · v1.17 scheduled autonomy (set-and-forget DCA with a crash-safe execution journal) · v1.16 daily velocity caps, shipped subagents, mainnet-guard hook · all releases

⚡ Quickstart — full step‑by‑step

This walkthrough takes you from zero to a running dashboard. Estimated time: 5 minutes (most of it Claude Code's first‑run download).

Step 1 — Install Claude Code

Claude Code is Anthropic's official CLI. If you already use it (you see the ▗ ▗ ▖ ▖ banner when you type claude in your terminal), skip to Step 2.

macOS / Linux:

curl -fsSL https://claude.ai/install.sh | bash

Follow the prompts. The installer drops a claude binary in your PATH.

Windows: download the installer from https://code.claude.com/download.

Verify:

claude --version
# → Claude Code v2.1.x

You also need an Anthropic account / Claude subscription — the installer walks you through claude login on first run.

Step 2 — Add the ChainGPT marketplace

Adding a marketplace just tells Claude Code "this GitHub repo is a place I can install plugins from." It does not install anything yet.

Open Claude Code (claude in your terminal). Inside the prompt, paste:

/plugin marketplace add ChainGPT-org/chaingpt-claude-skill

You'll see: ✓ Successfully added marketplace: chaingpt-claude-skill.

Behind the scenes Claude Code:

  1. Reads .claude-plugin/marketplace.json from the repo root.
  2. Clones the repo to ~/.claude/plugins/marketplaces/chaingpt-claude-skill/.
  3. Caches the plugin listing.

[!NOTE] The reason /plugin install <owner/repo> (single‑step) does not work here is that GitHub's <owner/repo> shorthand resolves only against Anthropic's curated public marketplace, and this plugin isn't (yet) listed there. The two‑step custom‑marketplace flow works today with no approval required.

Step 3 — Install the chaingpt plugin

Type in the Claude Code prompt:

/plugin

A picker opens listing available marketplaces and their plugins. Pick chaingpt-claude-skill → chaingpt → press Enter to install.

You'll see: ✓ Installed chaingpt. Run /reload-plugins to apply.

[!TIP] Shortcut if you don't want to use the picker: /plugin install chaingpt@chaingpt-claude-skill (one shot, no picker).

Step 4 — Reload plugins

Same Claude Code session:

/reload-plugins

This re‑scans installed plugins, spawns the ChainGPT MCP server over stdio, and registers all 23 sub‑skills + 131 MCP tools.

Alternative: quit Claude Code (/quit or Cmd+Q) and relaunch. Plugins are loaded at startup.

Step 5 — Set your API key (optional but recommended)

Without an API key, the dashboard works, all the on‑chain tools work (DEX swaps, Aave, Hyperliquid, etc. — they hit public endpoints), but the ChainGPT product tools fail (chat, NFT generation, contract audit, news — these need credits).

Drop this in your shell rc (~/.zshrc or ~/.bashrc):

export CHAINGPT_API_KEY="your-key-here"   # https://app.chaingpt.org → API Dashboard

Reload your shell (source ~/.zshrc) and re‑launch Claude Code.

Get a key + credits at https://app.chaingpt.org. 1,000 credits = $10. 15 % bonus if you pay in $CGPT.

[!IMPORTANT] Using Solana DeFi tools? (Marginfi deposit/withdraw, Jupiter swaps, Drift, Kamino.) Set a real Solana RPC — the default public endpoint rate‑limits the heavy on‑chain SDK fetches these tools rely on, so they'll be slow or fail. A free Helius / Triton / QuickNode endpoint is plenty:

export SOLANA_RPC_URL="https://your-solana-mainnet-rpc-url"

EVM tools don't need this — they ship with public‑RPC fallbacks per chain.

Step 6 — Verify it works

In a fresh Claude Code session:

/mcp

You should see chaingpt listed with 131 tools.

Step 7 — Open the dashboard

/chaingpt:dashboard

Claude calls the chaingpt_dashboard_serve MCP tool. It prints:

URL:         http://127.0.0.1:8788
Admin token: <48-char hex>

Open the URL in your browser. The login page asks for the admin token — paste it, click Unlock. You land on the Overview tab.

6 tabs available:

TabWhat it shows
OverviewPlugin / MCP / marketplace versions, skill count, agent‑wallet init status
WalletAgent EOA address, policy summary (kill switch, allowed chains, max value), tracked assets, link to launch the full Wallet Admin UI for editing
SkillsCard per sub‑skill with description from each SKILL.md
ActivityLast 50 signed transactions the agent has executed
HealthWhich env vars are set (presence only — never values), Node version, key paths
AboutPlugin metadata + top of CHANGELOG.md

The dashboard binds 127.0.0.1 only, the admin token rotates every time the server (re)starts, and the session cookie is HttpOnly + SameSite=Strict + 1 h TTL. The dashboard is read‑only — signing flows stay in MCP tool calls.

Step 8 — Optional: enable the Agent Wallet (only needed for "bounded autonomous" flows)

If you want Claude to sign and broadcast transactions itself within a policy you set, the Agent Wallet feature ships with the plugin. It's optional — if you just want the AI co‑pilot that returns unsigned transactions for you to sign in MetaMask / Rabby / Phantom, skip this step.

The keystore is AES‑256‑GCM encrypted with a passphrase. You have two ways to provide it:

Option A — zero‑setup (macOS / Linux with a keychain): just init. A strong 256‑bit passphrase is auto‑generated and stored in your OS keychain (macOS Keychain or Linux libsecret). You never type or remember it.

> initialize the agent wallet

Option B — explicit env var (CI / headless / maximum control): set a passphrase before launching Claude Code.

export CHAINGPT_AGENT_WALLET_PASSPHRASE="your-strong-passphrase-min-16-chars"
# then relaunch claude, and: > initialize the agent wallet

Either way, Claude calls chaingpt_agent_wallet_init and prints the new EOA address (and tells you which passphrase source it used). The default policy is now Balanced DeFi (kill switch OFF, 0.1‑native per‑tx cap, major DEX/lending routers allowlisted) — fund the address, review/tighten the policy in the dashboard, and you're set.

Back up the passphrase. Keychain option: security find-generic-password -s chaingpt-mcp-agent-wallet -a keystore-passphrase -w (macOS). Lose it with no backup → the keystore is unrecoverable.

For full wallet management (multi-chain balances, kill switch, 9 policy templates including 🚨 Unrestricted, custom-chain registration, blue-chip auto-scan), open the dedicated wallet admin UI:

> open the wallet admin UI

Claude calls chaingpt_agent_wallet_serve_ui. It prints a URL on http://127.0.0.1:8787 and its own admin token (separate from the dashboard's 8788 token).

Slash commands you'll use most

CommandWhat it does
/pluginPlugin picker — install / uninstall / enable plugins
/plugin marketplace add <owner/repo>Register a custom marketplace
/plugin install <plugin>@<marketplace>One-shot install without the picker
/reload-pluginsRe-scan installed plugins; needed after install / update / fork edits
/mcpList active MCP servers and their tool counts — sanity check
/chaingpt:dashboard [port]Open the marketplace dashboard. Optional port arg if 8788 is taken
/plugin marketplace update chaingpt-claude-skillPull the latest version from GitHub
/quitQuit Claude Code (plugins are loaded at startup, so this is the safe restart)

Troubleshooting

SymptomFix
Marketplace 'ChainGPT-org/chaingpt-claude-skill' not foundYou skipped Step 2. Run /plugin marketplace add ChainGPT-org/chaingpt-claude-skill first.
/plugin install ran but no chaingpt server in /mcpYou skipped Step 4 (/reload-plugins) or never restarted Claude Code. Plugins load at startup.
Unknown command: /chaingpt:dashboardThe plugin isn't installed or wasn't reloaded. Repeat Steps 3 + 4.
Dashboard URL prints but browser shows "can't connect"The dashboard server exited (the demo-test process might have ended). Re-run /chaingpt:dashboard to boot it again.
Dashboard login says "Invalid token"Tokens rotate every time the dashboard starts. Use the most recent token printed by the most recent /chaingpt:dashboard call.
Port 8788 already in use/chaingpt:dashboard 9999 (or any free port).
WARN: CHAINGPT_API_KEY is not set in MCP server logsOptional. The plugin still works; only the ChainGPT product tools (chat / NFT / audit / generator / news) will fail with a clear per-call message. Set the env var if you need those tools.
chaingpt_agent_wallet_init errors with passphrase complaintThe CHAINGPT_AGENT_WALLET_PASSPHRASE env var must be set in the same shell that launched Claude Code, with ≥16 chars. Quit Claude Code, export …, relaunch.
Solana DeFi tools (Marginfi deposit/withdraw, Jupiter, Drift) are slow or time out / 429The default public Solana RPC rate‑limits the heavy DeFi SDK fetches. Set SOLANA_RPC_URL to a real endpoint (Helius / Triton / QuickNode free tier) before launching Claude Code — see Step 5.

If you'd rather pin a specific commit or work from a fork:

# User-level (recommended — applies to every project)
git clone https://github.com/ChainGPT-org/chaingpt-claude-skill ~/.claude/plugins/chaingpt

# Or project-level
git clone https://github.com/ChainGPT-org/chaingpt-claude-skill .claude/plugins/chaingpt

Build the MCP server:

cd ~/.claude/plugins/chaingpt/mcp-server
npm install && npm run build

The plugin's .claude-plugin/plugin.json and .mcp.json are picked up automatically. /reload-plugins in any Claude Code session, then proceed from Step 5.

If you want only the MCP tools — no auto-loaded skills or reference docs — add the server directly to your Claude Code settings:

{
  "mcpServers": {
    "chaingpt": {
      "command": "node",
      "args": ["/absolute/path/to/chaingpt-claude-skill/mcp-server/dist/index.js"],
      "env": { "CHAINGPT_API_KEY": "your-key-here" }
    }
  }
}

You lose the intent-routing sub-skills, reference docs, templates, and patterns this way. Recommended only if you're integrating the MCP server into a non-Claude-Code host.

🎯 Why this exists

Building with Web3 AI APIs means juggling seven different domains in one task: an API surface (ChainGPT), DEX aggregators (OpenOcean / 1inch / CoW / Jupiter), risk scanners (GoPlus / Honeypot), on‑chain readers (Etherscan / Moralis / RPC), DeFi protocols (Aave / Lido / Pendle / Morpho), exchanges (Hyperliquid / Drift / Polymarket), cross‑chain bridges (Across), and the wallet signing that ties them together. Each has its own SDK, schema, error format, key management story, and rate‑limit gotchas. Most of an LLM's time is spent guessing parameters and burning credits on bad calls.

This skill collapses all of that into one toolkit Claude already knows. You describe the goal — "swap 5 ETH on Arbitrum but only if GoPlus says the buy token is safe" — and Claude orchestrates the seven calls, returns the unsigned transaction, and waits for you to sign in your wallet of choice. No SDK installs. No private‑key handoff. No "wait, which version of the OpenOcean API uses gmxV2?" archaeology.

Who it's for

RoleWhat you get from this
Solo Web3 devSkip the "30 SDKs, 3 docs sites, 12 schema versions" tax. Build a deploy pipeline, an MEV‑protected swap, or a portfolio dashboard from chat.
DeFi power userHealth‑factor monitor + automated stake/unstake + cross‑chain rebalance, all custody‑free, no on‑chain bot infrastructure required.
Hackathon teamThe chaingpt-hackathon skill scaffolds a working 5‑file Web3 + AI project in 60 seconds. 10 templates including multi‑product compositions (NFT Marketplace, DeFi Dashboard).
Quant / deskHyperliquid + Drift + Polymarket live data, Pendle yield discovery, Morpho vault analytics, strategy plan persistence + grid backtester, all from one toolkit.
Smart‑contract engineer45+ audited Solidity patterns Claude composes from. Mainnet deploy with mandatory audit gate. Verification via Etherscan v2 across every major EVM chain.
Agent builderThe agent gets its own EOA + policy file the LLM cannot bypass. Localhost admin dashboard with 9 policy templates + kill switch. Build "bounded autonomous" trading/yield bots safely.

🧠 How it works

Four cooperating layers. Each does one thing well. Claude routes between them automatically.

┌────────────────────────────────────────────────────────────────────────┐
│                              Claude Code                               │
└───────────────────────────────┬────────────────────────────────────────┘
                                │
        ┌───────────────────────┼───────────────────────┐
        ▼                       ▼                       ▼
┌──────────────────┐  ┌──────────────────┐  ┌──────────────────────┐
│  23 sub-skills   │  │ Reference docs   │  │ Templates + Patterns │
│  (intent → tool) │  │ (19 markdown)    │  │ (11 + 45)            │
│  Triggers route  │  │ Every endpoint   │  │ Production scaffolds │
│  Claude to the   │  │ + param + cost   │  │ + audited Solidity   │
│  right toolkit   │  │ + error code     │  │                      │
└────────┬─────────┘  └──────────────────┘  └──────────────────────┘
         │
         ▼
┌────────────────────────────────────────────────────────────────────────┐
│  MCP Server — 131 tools (the runtime)                                  │
│                                                                        │
│  ChainGPT AI       │  Web3 toolkit    │  Mainnet execution             │
│  • chat / NFT      │  • wallet scan   │  • EVM swap (OO/1inch/CoW)    │
│  • generator       │  • token research│  • Solana swap (Jupiter)      │
│  • auditor         │  • risk scan     │  • deploy + verify            │
│  • news            │  • on-chain read │  • Aave/Lido/EigenLayer       │
│                    │  • AI-enriched   │  • Hyperliquid + Drift        │
│  Agent wallet      │    intel         │  • Polymarket data            │
│  • encrypted EOA   │                  │  • Across bridge              │
│  • policy gate     │                  │  • Pendle + Morpho yield      │
│  • admin dashboard │                  │  • portfolio fan-out          │
│                    │                  │  • strategy plans + backtest  │
└────────────────┬───────────────────────┬──────────────────────────────┘
                 │                       │
                 ▼                       ▼
        ┌─────────────────┐     ┌─────────────────────────┐
        │  Mock Server    │     │  Real upstreams         │
        │  localhost:3001 │     │  (DexScreener, GoPlus,  │
        │  Zero credits   │     │   OpenOcean, Aave,      │
        │  for dev / CI   │     │   Hyperliquid, …)       │
        └─────────────────┘     └─────────────────────────┘

The four layers:

  1. Sub‑skills (skills/*/SKILL.md, 23 of them) — markdown files with YAML frontmatter that Claude Code auto‑routes based on intent. Examples: chaingpt-deploy triggers on "deploy a contract"; chaingpt-trade on "swap"; chaingpt-agent-wallet on "give the agent a wallet." Each sub‑skill bundles the relevant tools, mandatory pre‑flight checks, and links to deeper reference docs.

  2. Reference docs (reference/*.md, 20 files) — every endpoint, parameter, response shape, credit cost, and error code for the seven ChainGPT products. The skill loads these into Claude's context on demand so it never has to guess a parameter name.

  3. Templates + Patterns (templates/ + patterns/, 10 templates + 45+ Solidity patterns) — production‑ready scaffolds (Next.js chatbot, NFT marketplace, DeFi dashboard, React Native wallet, Nuxt news app, …) and audited Solidity (ERC‑20 variants, ERC‑4626 vaults, UUPS upgradeable, Governor, role‑based access, timelocks, …). Claude composes from these instead of regenerating boilerplate from scratch.

  4. MCP Server (mcp-server/, 131 tools) — the runtime. A @modelcontextprotocol/sdk server that exposes every state‑changing capability as an MCP tool. Direct API calls, on‑chain reads via public RPC, custody‑free transaction building. Claude doesn't write code that calls APIs — Claude calls them directly through the MCP layer.

Plus a mock server (mock-server/) — a full drop‑in replacement for the ChainGPT API at http://localhost:3001. Realistic responses, simulated latency, credit tracking. Build and CI without burning a single credit.

🔐 Security model

The single design choice that everything else follows from: the plugin never sees a private key for funds the user controls. Every state‑changing tool builds an unsigned transaction (EVM) or signed EIP‑712 intent (Hyperliquid / Polymarket) and hands it back. You sign in whatever wallet you already trust — MetaMask, Rabby, Trust, Phantom, hardware wallet (Ledger / Trezor via the same flow), WalletConnect, or your own custom signer.

ThreatDefense
Drained funds via prompt‑injected "send everything to attacker"The plugin doesn't hold keys for user wallets. The agent wallet (a separate optional feature) has an admin policy gate in code (not in the LLM prompt) that refuses out‑of‑policy txs even under successful prompt injection.
Accidental mainnet broadcastEvery state‑changing mainnet tool refuses without acknowledgeMainnet: true. The refusal message lists exactly what to verify.
Unaudited deploychaingpt_deploy_build_tx requires a prior chaingpt_audit_contract pass on mainnet. The chaingpt-deploy skill enforces the audit step.
Honeypot / rug / sanctioned addresschaingpt_risk_token + chaingpt_risk_honeypot + chaingpt_risk_address integrate GoPlus + Honeypot.is. The chaingpt-trade skill makes risk check mandatory before any build_swap_tx.
Leaked API key in sourceCHAINGPT_API_KEY lives in env only. Daemon paths refuse to start if the env var is missing. CI fails on literal API‑key patterns in source.
Tx replay across chainsEvery signed payload includes chainId or equivalent (EIP‑712 domain on EVM; chain‑specific addresses on Solana; HL's L1 source byte; Polymarket's CTF domain).

The agent wallet is the one place the plugin can hold a key — but only the agent's own key, encrypted with a passphrase the agent never sees, gated by a policy file the agent has no tool to write. See the dashboard section for the full threat model and admin flow.

🖥️ The Agent Wallet Dashboard

Ships with a real localhost wallet UI for the AI agent — not just a CLI. Encrypted EOA keystore, admin‑controlled policy gate the agent cannot bypass even under prompt injection, kill switch, 9 policy templates including 🚨 unrestricted mode, custom EVM chain registration, blue‑chip auto‑scan.

Launch it locally in 30 seconds:

# 1. Set a strong passphrase (>=16 chars) for the encrypted keystore
export CHAINGPT_AGENT_WALLET_PASSPHRASE="your-strong-passphrase-here-min-16-chars"

# 2. Try the dashboard without touching your real ~/.chaingpt-mcp/ files
node scripts/demo-agent-wallet-dashboard.mjs

Open http://127.0.0.1:8787/. The console prints a one‑time admin token — paste it at the login screen.

Why this is prompt‑injection‑resistant:

  1. Policy lives in a JSON file (~/.chaingpt-mcp/agent-wallet/policy.json). No MCP tool can write it — admin edits via the localhost dashboard or a text editor.
  2. Every sign_and_send call loads the policy file fresh and runs checkPolicy(intent) — pure deterministic code that doesn't see the LLM's context. Refuses if any rule fails (kill switch, chain whitelist, address allow/blocklist, value cap, gas cap, selector blocklist, memo requirement).
  3. The LLM has no MCP tool that issues arbitrary HTTP requests, so it cannot reach the localhost dashboard's edit endpoints either.
  4. Default policy is fail‑closed (killSwitch: true). Admin must explicitly opt in.

Security: bound to 127.0.0.1 only — never 0.0.0.0. Origin + Referer check on every POST. Session cookie HttpOnly + SameSite=Strict + 1h sliding TTL. Admin token rotated on every restart. Atomic write + .bak backup at 0600.

🔌 MCP Server — 131 Tools

The MCP server gives Claude direct API and on‑chain access — not just code generation. 131 tools across 15 categories. Detailed sections follow.

CategoryToolsNotes
ChainGPT AI products (chat / NFT / audit / generator / news)18Core ChainGPT API surface
Web3 toolkit (wallet / research / risk / on‑chain)1411 chains incl. Solana
AI‑enriched composed tools2DexScreener + GoPlus + ChainGPT news + AI signal in one call
Mainnet contract deployment5Custody‑free, mandatory audit gate
Mainnet DEX trading (OpenOcean + 1inch + CoW + Jupiter)9Custody‑free
Mainnet DeFi (Aave / Lido / EigenLayer / Pendle / Morpho)12Custody‑free, health‑factor gate
Perps (Hyperliquid + Drift)14Read‑only on Drift; HL signed EIP‑712 actions
Polymarket prediction markets6Read + signed CTF/Neg‑Risk orders
Cross‑chain bridge (Across v3)310 EVM mainnets
Solana lending (Marginfi + Kamino)8Reads + custody‑free Marginfi & Kamino deposit/withdraw (mainnet‑verified, simulated)
Solana signing foundation + SPL transfer2Custody‑free VersionedTransaction, classic + Token‑2022
ERC‑4337 v0.7 account‑abstraction foundation4userOpHash, pack, bundler‑RPC proxy
x402 agentic payments4EIP‑3009 X‑PAYMENT builder, facilitator verify/settle, monetize endpoints
Base — Basenames3Forward/reverse resolution (mainnet‑verified) + registration tx
Base App / Farcaster Mini Apps3farcaster.json manifest, fc:miniapp embed, validation
ERC‑8004 Trustless Agents3Agent identity/AgentCard resolution (mainnet‑verified) + card generator
Multi‑protocol portfolio + strategy plans + backtest6 + 1One‑shot snapshot across 4 protocols
Agent wallet (encrypted EOA + admin policy gate)7LLM cannot bypass policy
Utility (credit estimate, balance)2
Total131

x402 agentic payments · Base · ERC‑8004 (13 tools, new in 1.15)

The agent‑economy layer: pay for things autonomously, get a human‑readable identity on Base, and carry a portable on‑chain reputation. All custody‑free.

ToolWhat it does
chaingpt_x402_decodeDecode an x402 402 challenge / X‑PAYMENT header into human terms before paying
chaingpt_x402_build_paymentBuild the UNSIGNED EIP‑3009 transferWithAuthorization typed data; return the X‑PAYMENT header once signed
chaingpt_x402_facilitatorCall a facilitator — supported / verify / settle
chaingpt_x402_create_requirementsGenerate PaymentRequirements + a 402 body to monetize your own API
chaingpt_base_resolve_nameResolve name.base.eth ↔ address (forward + reverse) — verified live on Base mainnet
chaingpt_base_name_availabilityIs a Basename available + its price for N years
chaingpt_base_register_name_txUNSIGNED Basename registration tx (sets addr + reverse record); mainnet gated
chaingpt_miniapp_manifestGenerate /.well-known/farcaster.json for a Base App / Farcaster Mini App
chaingpt_miniapp_embedGenerate the fc:miniapp (+ legacy fc:frame) share embed meta tag
chaingpt_miniapp_validateValidate a Mini App manifest against the spec
chaingpt_erc8004_resolve_agentResolve an ERC‑8004 agent → owner + AgentCard — verified live on Base mainnet
chaingpt_erc8004_registriesCanonical Identity/Reputation registry addresses (the 0x8004… singletons)
chaingpt_erc8004_agentcardGenerate a spec‑compliant registration-v1 AgentCard (incl. x402Support)

x402 settles in USDC on Base via EIP‑3009 — the facilitator can only broadcast the signed authorization, never change the amount or recipient. Basenames + ERC‑8004 reads use a public‑RPC fallback chain; set BASE_RPC_URL for heavy use. ERC‑8004 write/registration is intentionally deferred while the draft EIP's write ABIs stabilize (read + AgentCard scaffolding ship now). See the chaingpt:x402, chaingpt:base, and chaingpt:trustless-agents skills.

ChainGPT AI products (18 tools)

ToolWhat it does
chaingpt_chatAsk the Web3 AI chatbot — crypto‑native LLM with live on‑chain data
chaingpt_chat_with_contextBranded chatbot with company / token context injection
chaingpt_chat_historyRetrieve past conversations by session id
chaingpt_nft_generate_image · _enhance_prompt · _generate_and_mint · _get_chainsGenerate AI art, mint on 22+ chains
chaingpt_audit_contractAI security audit with scored report
chaingpt_generate_contractNatural language → production Solidity
chaingpt_news_fetch · chaingpt_news_categoriesCrypto news with category + token filters
chaingpt_estimate_credits · chaingpt_check_balanceCost + balance utilities

Web3 toolkit (14 tools)

Across 11 chains: ethereum, base, arbitrum, optimism, polygon, bsc, avalanche, blast, linea, scroll, solana.

ToolWhat it doesBackend
chaingpt_wallet_balances · _positions · _pnlMulti‑chain native + ERC‑20 balances, DeFi positions, realized + unrealized P&LMoralis (opt) + RPC
chaingpt_research_token · _pairs · _trendingPrice, liquidity, volume, all trading pairs, trending tokensDexScreener
chaingpt_risk_token · _honeypot · _address · _contract_sourceHoneypot / mintable / proxy flags, buy + sell simulation, sanctions / phishing check, verified source codeGoPlus + Honeypot + Etherscan v2
chaingpt_onchain_tx · _address · _gas · _blockDecode any tx, recent activity, multi‑chain gas oracle, block infoEtherscan v2 + RPC

AI‑enriched composed tools

These are the strategic differentiator — pure aggregation tools wrapped in ChainGPT's AI layer.

ToolWhat it does
chaingpt_intel_tokenOne call → DexScreener + GoPlus + ChainGPT news + AI signal. The "research this token" tool. ~1 credit.
chaingpt_intel_walletPortfolio + per‑holding risk rating across chains. Free read.

Mainnet contract deployment (5 tools)

Custody‑free. The plugin builds an unsigned tx; the user signs externally. MAINNET is the default; testnet is opt‑in via the network parameter.

ToolWhat it does
chaingpt_deploy_compileSolidity 0.8.x → bytecode + ABI + warnings
chaingpt_deploy_estimatePreview gas cost on the target chain
chaingpt_deploy_build_txRefuses mainnet without acknowledgeMainnet: true
chaingpt_deploy_verify · _verify_statusSubmit source to Etherscan v2; poll the GUID

Mainnets (default): ethereum · base · arbitrum · optimism · polygon · bsc · avalanche · blast · linea · scroll. Testnets (opt‑in): sepolia · base‑sepolia · arbitrum‑sepolia · optimism‑sepolia · polygon‑amoy · bsc‑testnet.

The chaingpt-deploy skill enforces the mandatory pipeline: generate → audit → compile → estimate → confirm → build‑tx → user‑signs → verify.

Mainnet DEX trading (9 tools)

Custody‑free. Same acknowledgeMainnet safety pattern.

ToolBackend
chaingpt_dex_quote · _build_swap_tx · _approve_txOpenOcean v4 (EVM)
chaingpt_dex_jupiter_quote · _jupiter_build_swap_txJupiter v6 (Solana)
chaingpt_dex_1inch_quote · _1inch_build_swap_tx1inch v6 (EVM, key‑gated)
chaingpt_dex_cow_quote · _cow_create_orderCoW Protocol (EVM, intent‑based, MEV‑protected)

The chaingpt-trade skill codifies the mandatory pre‑flight: chaingpt_risk_token on the buy token + chaingpt_dex_quote BEFORE any build_swap_tx.

Mainnet DeFi protocols (12 tools)

Custody‑free. chaingpt-defi skill enforces a chaingpt_defi_aave_health check before any borrow / withdraw.

ToolWhat it does
chaingpt_defi_aave_health · _supply_tx · _borrow_tx · _repay_tx · _withdraw_txAave V3 on 7 chains
chaingpt_defi_lido_stake_txStake native ETH → stETH on Lido
chaingpt_defi_eigenlayer_deposit_txRestake stETH / rETH / cbETH on EigenLayer
chaingpt_defi_pendle_markets · _marketPendle yield‑strip discovery — fixed APY, implied APY, YT, maturity
chaingpt_defi_morpho_markets · _vaults · _userMorpho Blue isolated markets + MetaMorpho curated vaults

Aave V3 chains: ethereum, base, arbitrum, optimism, polygon, bsc, avalanche.

Perps — Hyperliquid + Drift (14 tools)

Live mainnet data. Hyperliquid supports signed EIP‑712 L1 actions (custody‑free order placement). Drift is read‑only in this release.

ToolWhat it does
chaingpt_hl_markets · _mids · _orderbook · _account · _fills · _fundingRead HL market data + account state
chaingpt_hl_place_order_payload · _cancel_order_payload · _update_leverage_payloadEIP‑712 signed intents — user wallet finalizes
chaingpt_drift_markets · _market · _orderbook · _funding · _userRead Drift perp markets, orderbook, funding, user account

Polymarket prediction markets (6 tools)

ToolWhat it does
chaingpt_pm_markets · _market · _orderbook · _tradesDiscover markets + read live data
chaingpt_pm_create_order · _create_neg_risk_orderEIP‑712 signed CTF / Neg‑Risk order intents

Cross‑chain bridging (3 tools)

ToolWhat it does
chaingpt_bridge_quote · _build_deposit_tx · _statusAcross Protocol v3 across 10 EVM mainnets

Solana lending (4 tools, read‑only)

ToolWhat it does
chaingpt_defi_marginfi_banks · _accountMarginfi v2 banks + user account
chaingpt_defi_kamino_markets · _vaultsKamino markets + automated yield vaults

Portfolio + strategy plans + backtest (7 tools)

ToolWhat it does
chaingpt_portfolio_snapshotFan‑out parallel to HL + PM + Morpho + Drift for one user
chaingpt_strategy_dca · _grid · _funding_arb · _copy_tradeStrategy template planners
chaingpt_strategy_save_plan · _load_plan · _list_plans · _delete_planPersist strategy plans to ~/.chaingpt-mcp/plans/
chaingpt_backtest_gridReplay a buy/sell ladder against historical CoinGecko prices; reports realized P&L from grid spreads vs buy‑and‑hold

Agent wallet (7 tools)

See the dashboard section for the threat model and admin flow.

ToolWhat it does
chaingpt_agent_wallet_initAES‑256‑GCM encrypted keystore, scrypt KDF
chaingpt_agent_wallet_address · _status · _balances · _policyRead‑only views
chaingpt_agent_wallet_sign_and_sendOnly fund‑moving tool. Policy gate runs deterministically; refuses with reason on any violation.
chaingpt_agent_wallet_serve_uiStart the localhost admin dashboard on 127.0.0.1:8787

Optional API keys

The plugin works without these but unlocks more if present:

Env varUnlocksGet one
MORALIS_API_KEYFull multi‑chain ERC‑20 scan + DeFi positions + P&Lhttps://moralis.io (25k req/month free)
ETHERSCAN_API_KEYHigher Etherscan rate limit (Etherscan v2 covers every major EVM chain)https://etherscan.io/myapikey (free)
ONEINCH_API_KEY1inch v6 aggregator routinghttps://portal.1inch.dev

📦 ChainGPT products covered

ProductWhat it doesCost
Web3 AI Chatbot & LLMCrypto‑native LLM with live on‑chain data, Nansen Smart Money, 33+ chains0.5 credits
AI NFT GeneratorText‑to‑image + on‑chain minting across 22+ chains, 4 AI models1–14.25 credits
Smart Contract GeneratorNatural language → production Solidity1 credit
Smart Contract AuditorAI vulnerability detection with scored audit reports1 credit
AI Crypto NewsReal‑time AI‑curated news, 24 categories, RSS feeds0.1 credits
AgenticOSOpen‑source autonomous X/Twitter AI agents1 credit/tweet
Solidity LLMOpen‑source 2B‑param model for Solidity code generationFree

Plus SaaS & Whitelabel references — Launchpad, Staking, Vesting, Telegram bots.

1 credit = $0.01 USD · 15% bonus when paying with $CGPT.

📋 10 Project Templates

TemplateStackChainGPT products
Web3 AI ChatbotExpress + TypeScriptLLM
NFT Minting ServiceNode.jsNFT Generator
Contract Audit CI/CDGitHub ActionsAuditor
Crypto News DashboardVanilla JSNews API
AI Twitter AgentNode.jsAgenticOS
NFT MarketplaceNext.js + wagmiNFT + LLM + Auditor + News
DeFi DashboardReact + RechartsLLM + News + Auditor
Next.js ChatbotNext.js 14 App RouterLLM
React Native WalletExpo + React NativeLLM + NFT
Nuxt News AppNuxt 3 SSRNews API

🔐 45+ Smart Contract Patterns

Audited, production‑ready Solidity patterns Claude composes from instead of generating from scratch:

CategoryCountExamples
ERC‑20 Tokens10Basic, burnable, taxable, reflection, governance, multi‑chain
NFTs10ERC‑721, 721A, lazy mint, soulbound, dynamic, ERC‑1155, revenue‑sharing
DeFi10Staking, vesting, bonding curve, AMM, flash loans, ERC‑4626 vault
Governance5Governor, multi‑sig, DAO treasury, delegation
Security10Access control, upgradeable (UUPS), timelock, escrow, EIP‑712

💬 Usage examples

Just talk to Claude naturally:

"Build me a Web3 AI chatbot with streaming responses"
"Generate and mint an NFT on Base using ChainGPT"
"Set up smart contract auditing in my CI/CD pipeline"
"Scaffold an NFT marketplace that uses 4 ChainGPT products"
"What's the credit cost for generating 100 NFTs with NebulaForge XL?"
"Write a staking contract"   →  uses patterns library, not from scratch
"I'm migrating from OpenAI — help me switch to ChainGPT"
"I'm at a hackathon — scaffold me a DeFi project fast"

End‑to‑end DeFi flow:

You: "I want to long ETH 5x on Hyperliquid but check the funding rate first.
      If funding is paying shorts, post a limit order at -1.5% from mid."

Claude: → chaingpt_hl_markets
        → chaingpt_hl_funding  (ETH 8h funding rate: -0.0042% → shorts pay longs ✓)
        → chaingpt_hl_orderbook(symbol=ETH, depth=20)  (mid: 4218.5)
        → chaingpt_hl_place_order_payload(symbol=ETH, side=buy, size=5000,
                                          price=4155.2, leverage=5,
                                          tif=Gtc)
        ✓ EIP-712 intent ready. Paste this into your HL signer to broadcast:
        { "action": {...}, "nonce": ..., "signature": "0x..." }

Custody‑free deploy:

You: "Generate an ERC-4626 vault for a yield strategy on Arbitrum,
      audit it, then prepare a mainnet deploy. Don't broadcast."

Claude: → chaingpt_generate_contract(...)
        → chaingpt_audit_contract(...)  (score: 9.2/10 — no critical issues)
        → chaingpt_deploy_compile(...)  (bytecode: 0x60806040..., ABI: [...])
        → chaingpt_deploy_estimate(network=arbitrum)  (estimated cost: 0.018 ETH)
        → chaingpt_deploy_build_tx(network=arbitrum, acknowledgeMainnet=true)
        ✓ Unsigned tx ready. Open MetaMask / Rabby / Ledger and broadcast.
        After confirmation, run:
          chaingpt_deploy_verify(address=…, network=arbitrum)

💰 Pricing & credits

ItemPrice
1 credit$0.01 USD
Pay with $CGPT15% bonus credits
Mock serverFree, unlimited (http://localhost:3001)
Live‑smoke CI daily runFree (uses public endpoints; ChainGPT‑side calls use a smoke key)
Web3 AI GrantUp to $1,000,000 for projects built on ChainGPT — grant page
Pad Innovation GrantUp to $25,000 for hackathon / pilot projects — grant page

Per‑product credit costs are in reference/pricing.md and chaingpt_estimate_credits returns a quote before you spend.

🧪 Testing

Use the mock server to develop and test without spending a single credit.

The mock server is a full drop‑in replacement for the ChainGPT API — realistic responses, simulated latency, credit tracking — so you can build, iterate, and run CI/CD pipelines without touching your API quota.

cd .claude/skills/chaingpt/mock-server
npm install && npm run dev
# → http://localhost:3001

Point your CHAINGPT_BASE_URL at http://localhost:3001 and everything works exactly as it would in production. No API key required.

Run the full test suite

./scripts/test-all.sh           # everything (offline + live smoke, ~50s)
./scripts/test-all.sh --fast    # everything except live smoke (~20s)
./scripts/test-all.sh --only mcp-test    # one layer only

The orchestrator runs six layers — see TESTING.md for the full reference.

LayerPass countNetwork
validate (structural / frontmatter checks)159none
typecheck (tsc --noEmit for both servers)cleannone
mcp-test (vitest — handlers, policy gate, signing, schemas)365none
mock-test (vitest — mock‑server endpoints via supertest)26none
examples (node --check + python3 -m ast)every filenone
smoke (live mainnet APIs)39yes

CI runs the first four on every push and PR (.github/workflows/ci.yml). Smoke runs daily plus on‑demand and opens a labeled GitHub issue on scheduled‑run failure.

The contract: every PR that adds a tool or behavior must add tests in the same PR. See TESTING.md.

📊 How this compares

There are several Web3 + AI agent toolkits in flight. They aim at the same outcome (let an LLM call Web3 surfaces) but pick different trade‑offs.

This skillGoat SDK (Crossmint)Coinbase AgentKitMetaMask Snaps + MCPHeurist
Surface131 MCP tools across 11 categories incl. perps + prediction markets + cross‑chain + agent walletPlugin per protocol (extensible)EVM swap + on‑chain + Base‑nativeWallet + LLM bridgeImage gen + LLM marketplace
Custody modelUser‑sovereign default + bounded agent EOA with admin policy gateUser‑sovereignUser wallet (CDP) or smart walletMetaMask signs everythingN/A (no signing)
Mainnet safetyMandatory acknowledgeMainnet: true + audit‑before‑deploy gatePer‑pluginDefault mainnetMetaMask UI confirmationN/A
AI enrichmentDexScreener + GoPlus + News + AI signal composed into one callNone nativeNone nativeNone nativeImage + LLM only
Cost transparencyPer‑tool credit costs surfaced; mock server freeLLM tokens onlyGas onlyGas onlyPer‑model
Solidity codegen + auditNative (chaingpt_generate_contract + chaingpt_audit_contract)NoNoNoNo
Prediction marketsPolymarket nativeNoNoNoNo
PerpsHyperliquid (signed) + Drift (read)Add‑onNoNoNo
Spending limits under autonomyPer‑tx cap + rolling‑24h spend/tx‑count caps enforced in code the LLM can't modifyNoSmart‑wallet policies (CDP)Per‑tx MetaMask approvalN/A
Scheduled execution safetyCrash‑safe execution journal (re‑runs can't double‑buy)NoNoNoNo
Shipped agents3 (researcher / auditor / trader) with tuned guardrailsNoNoNoNo
Test harness6 layers + daily live smoke + self‑healing CI (drift auto‑PRs)Per‑pluginExamples onlySnap testingNone
LicenseMITMITApache‑2MITVarious

Where this wins: breadth (131 tools), AI‑enriched composed tools (the DexScreener + GoPlus + News + AI signal combo), mainnet safety guard rails, and the agent‑wallet admin dashboard.

Where Goat / AgentKit win: if you want pluggable per‑protocol extensions over a fixed core surface, Goat's plugin model is cleaner. If you're Coinbase‑native (CDP, Base, Smart Wallet end‑to‑end), AgentKit is the obvious choice.

These aren't mutually exclusive — you can run this skill alongside any of them in Claude Code.

🗂️ Project structure

chaingpt-claude-skill/
├── .claude-plugin/
│   └── plugin.json                   # Plugin manifest (name, version, author)
├── .mcp.json                         # MCP server configuration
├── VERSION                           # Semantic version
├── README.md                         # This file
├── CONTRIBUTING.md
├── CHANGELOG.md
├── TESTING.md                        # Testing guide — six-layer harness
├── LICENSE
│
├── skills/                           # 23 sub-skills (auto-discovered)
│   ├── chaingpt/SKILL.md             #   Main skill — API reference + tool routing
│   ├── agent-wallet/SKILL.md         #   AI's own EOA with admin policy gate
│   ├── bridge/SKILL.md               #   Across cross-chain
│   ├── debug/SKILL.md                #   Troubleshoot API errors
│   ├── defi/SKILL.md                 #   Aave + Lido + EigenLayer + Pendle + Morpho
│   ├── deploy/SKILL.md               #   Mainnet contract deployment
│   ├── drift/SKILL.md                #   Drift perps on Solana (read-only)
│   ├── hackathon/SKILL.md            #   60-second project scaffolder
│   ├── hyperliquid/SKILL.md          #   Hyperliquid perps
│   ├── playground/SKILL.md           #   Interactive API testing
│   ├── polymarket/SKILL.md           #   Polymarket prediction markets
│   ├── research/SKILL.md             #   Token research + DexScreener
│   ├── security/SKILL.md             #   Honeypot + risk + audit
│   ├── aa/SKILL.md                   #   ERC-4337 v0.7 account abstraction
│   ├── base/SKILL.md                 #   Basenames + Base Mini Apps
│   ├── dashboard/SKILL.md            #   Localhost marketplace dashboard
│   ├── scheduled-autonomy/SKILL.md   #   Run saved strategies on a schedule (journal + caps)
│   ├── solana/SKILL.md               #   Solana signing foundation + transfers
│   ├── strategy/SKILL.md             #   Plan persistence + backtest
│   ├── trade/SKILL.md                #   OpenOcean / 1inch / CoW / Jupiter
│   ├── trustless-agents/SKILL.md     #   ERC-8004 agent identity/reputation
│   ├── x402/SKILL.md                 #   x402 agentic payments (HTTP 402)
│   └── update/SKILL.md               #   Check for skill updates
│
├── reference/                        # API & SDK documentation (20 files)
├── templates/                        # 10 project templates (+ composition guide)
├── patterns/                         # 45+ Solidity patterns (6 files)
├── migration/                        # Platform migration guides (3 files)
├── mcp-server/                       # MCP server — 131 tools, 365 vitest cases
├── mock-server/                      # Mock API for zero-credit dev — 26 tests
├── scripts/                          # validate.sh + test-all.sh + demo launcher
└── examples/                         # Working code — JS + Python

🗺️ Roadmap

Shipped (1.0 → 1.9)

  • Complete API reference for all 7 ChainGPT products
  • 131 MCP tools across ChainGPT AI, EVM + Solana DEX (OpenOcean · 1inch v6 · CoW · Jupiter), DeFi (Aave · Lido · EigenLayer · Pendle · Morpho), perps (Hyperliquid · Drift), prediction markets (Polymarket), cross‑chain (Across), Solana lending (Marginfi · Kamino), multi‑protocol portfolio snapshot, strategy plan persistence + backtest
  • Agent wallet — encrypted keystore + prompt‑injection‑resistant admin policy gate + localhost admin dashboard (assets / policy / activity / settings tabs, kill switch, 9 policy templates including 🚨 unrestricted)
  • Custody‑free signing — every state‑changing tool returns an unsigned tx / EIP‑712 intent; the plugin never sees a private key. acknowledgeMainnet: true gate on every mainnet write
  • 10 project templates including multi‑product compositions
  • 45+ audited Solidity patterns
  • Mock server for zero‑credit development (26 endpoint tests)
  • Unified test harness — ./scripts/test-all.sh runs six layers. 365 vitest + 26 mock + 159 validate + 39 live‑API cases
  • Daily live‑API smoke CI — catches upstream drift within 24h, opens a labeled GitHub issue on failure
  • Migration guides (OpenAI, Alchemy, custom)
  • Cost optimization & wallet integration docs
  • ERC‑4337 v0.7 foundation — userOpHash, PackedUserOperation packing, bundler‑RPC proxy. 4 MCP tools. Per‑provider session‑key issuance (Safe / Kernel / Biconomy / Alchemy SW) queued as follow‑ups.
  • SSE streaming demo — examples/sse/ wraps the General Chat stream as Server‑Sent Events with a browser EventSource client.
  • Multi‑language SDK examples (Go, Rust) — examples/go/ (stdlib only) + examples/rust/ (reqwest blocking + serde + rustls) calling the public API gateway.

In review (open PRs)

  • CI protective gates (PR #29) — solidity pattern compilation, MCP boot smoke, version consistency. Adds two CI jobs; six → eight test layers.
  • Solana signing foundation (PR #30) — custody‑free VersionedTransaction builder + native SOL + SPL transfer tools. +2 tools, +29 tests. Drift/Marginfi/Kamino signed actions queued as follow‑up PRs that layer on this.

Next up

  • Drift / Marginfi / Kamino signed actions — bring each from read‑only to signed execution on top of PR #30's Solana foundation
  • Per‑provider ERC‑4337 session‑key issuance — Safe, Kernel (ZeroDev), Biconomy, Alchemy SW on top of the foundation already shipped
  • Claude Code plugin marketplace listing
  • Video tutorials & walkthroughs
  • Community template submissions

🤝 Contributing

Contributions are welcome! See CONTRIBUTING.md for guidelines.

# Validate your changes before submitting
bash scripts/validate.sh

📄 Prerequisites

RequirementLink
ChainGPT API Keyapp.chaingpt.org — connect a wallet to sign up
API CreditsBuy credits — 1,000 credits = $10
Claude Codecode.claude.com

🔗 Links

Developer Docs · API Dashboard · Pricing · Web3 AI Grant ($1M) · Pad Innovation Grant ($25K)

Solidity LLM on HuggingFace · AgenticOS on GitHub · Book a SaaS Demo

📜 License

MIT — see LICENSE for details.


Built by ChainGPT — AI Infrastructure for Web3

If this skill saved you time, consider giving it a ⭐

Ver o original no GitHub

Bom para

Relacionados