ChainGPT Developer Kit for Claude Code

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

One install gives Claude Code 154 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), Tron (TVM) (TRC‑20, SunSwap, JustLend, agent‑wallet signing), 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

⚡ Install (2 commands)

In the Claude Code prompt, paste these two lines:

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

Then fully restart Claude Code (quit and relaunch) — or run /reload-plugins --force. The plugin ships an MCP server, so a plain /reload-plugins won't load it. First launch installs dependencies once (~30–60s). Verify with /mcp — you'll see chaingpt connected.

That's it. Optional API key (only for the ChainGPT chat / NFT / audit / news tools — everything on-chain works without it) and the guided walkthrough are in the full Quickstart.

Don't have Claude Code yet? Install it first, then run the two commands above.

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

Windows: download from https://code.claude.com/download. More detail in Step 1.

👀 60-second tour

Agent wallet refuses an over-cap transfer

The agent tries to overspend; the policy gate — a file the model has no tool to write — refuses in code. Prompt injection gets a refusal, not your funds.

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 are Start here Your 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-trader MCP 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.22 Tron (TVM) integration — non-EVM chain at EVM/Solana parity (14 tools, reuses the EVM key, fail-closed tron policy, SunSwap + JustLend) · v1.19 Solana signing parity (Ed25519 agent wallet, simulation-priced lamport caps) · 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 — Load the plugin

Same Claude Code session:

/reload-plugins

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

[!IMPORTANT] Because this plugin ships an MCP server, /reload-plugins may warn that it can't apply the MCP change in‑place and skip it — in which case the plugin won't appear in /plugin or /mcp. If that happens, run /reload-plugins --force, or just quit Claude Code (/quit or Cmd+Q) and relaunch. A full restart is the most reliable way to load the plugin and its MCP server, since plugins are loaded at startup. After a fresh install the MCP server also runs a one‑time npm install on first launch (~30–60s) before it shows connected.

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

Tab What it shows
Overview Plugin / MCP / marketplace versions, skill count, agent‑wallet init status
Wallet Agent EOA address, policy summary (kill switch, allowed chains, max value), tracked assets, link to launch the full Wallet Admin UI for editing
Skills Card per sub‑skill with description from each SKILL.md
Activity Last 50 signed transactions the agent has executed
Health Which env vars are set (presence only — never values), Node version, key paths
About Plugin 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

Command What it does
/plugin Plugin 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-plugins Re-scan installed plugins; needed after install / update / fork edits
/mcp List 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-skill Pull the latest version from GitHub
/quit Quit Claude Code (plugins are loaded at startup, so this is the safe restart)

Troubleshooting

Symptom Fix
Marketplace 'ChainGPT-org/chaingpt-claude-skill' not found You skipped Step 2. Run /plugin marketplace add ChainGPT-org/chaingpt-claude-skill first.
/plugin install ran but the plugin / chaingpt server doesn't show up in /plugin or /mcp /reload-plugins skipped the MCP change in‑place. Run /reload-plugins --force, or fully quit Claude Code and relaunch — plugins + MCP servers load at startup. (Reinstalling in the same session won't take effect until then.)
Unknown command: /chaingpt:dashboard The plugin isn't installed or wasn't loaded. Repeat Steps 3 + 4 (use /reload-plugins --force or restart).
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 logs Optional. 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 complaint The 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 / 429 The 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

Role What you get from this
Solo Web3 dev Skip 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 user Health‑factor monitor + automated stake/unstake + cross‑chain rebalance, all custody‑free, no on‑chain bot infrastructure required.
Hackathon team The 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 / desk Hyperliquid + Drift + Polymarket live data, Pendle yield discovery, Morpho vault analytics, strategy plan persistence + grid backtester, all from one toolkit.
Smart‑contract engineer 45+ audited Solidity patterns Claude composes from. Mainnet deploy with mandatory audit gate. Verification via Etherscan v2 across every major EVM chain.
Agent builder The 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                               │
└───────────────────────────────┬────────────────────────────────────────┘
                                │
        ┌───────────────────────┼───────────────────────┐
        ▼                       ▼                       ▼
┌──────────────────┐  ┌──────────────────┐  ┌──────────────────────┐
│  24 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 — 154 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/, 154 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.

Threat Defense
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 broadcast Every state‑changing mainnet tool refuses without acknowledgeMainnet: true. The refusal message lists exactly what to verify.
Unaudited deploy chaingpt_deploy_build_tx requires a prior chaingpt_audit_contract pass on mainnet. The chaingpt-deploy skill enforces the audit step.
Honeypot / rug / sanctioned address chaingpt_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 source CHAINGPT_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 chains Every 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 — 154 Tools

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

Category Tools Notes
ChainGPT AI products (chat / NFT / audit / generator / news) 18 Core ChainGPT API surface
Web3 toolkit (wallet / research / risk / on‑chain) 14 12 chains incl. Solana + Tron
AI‑enriched composed tools 2 DexScreener + GoPlus + ChainGPT news + AI signal in one call
Mainnet contract deployment 5 Custody‑free, mandatory audit gate
Mainnet DEX trading (OpenOcean + 1inch + CoW + Jupiter) 9 Custody‑free
Mainnet DeFi (Aave / Lido / EigenLayer / Pendle / Morpho) 12 Custody‑free, health‑factor gate
Perps (Hyperliquid + Drift) 14 Read‑only on Drift; HL signed EIP‑712 actions
Polymarket prediction markets 6 Read + signed CTF/Neg‑Risk orders
Cross‑chain bridge (Across v3) 3 10 EVM mainnets
Solana lending (Marginfi + Kamino) 8 Reads + custody‑free Marginfi & Kamino deposit/withdraw (mainnet‑verified, simulated)
Solana signing foundation + SPL transfer 2 Custody‑free VersionedTransaction, classic + Token‑2022
ERC‑4337 v0.7 account‑abstraction foundation 4 userOpHash, pack, bundler‑RPC proxy
x402 agentic payments 4 EIP‑3009 X‑PAYMENT builder, facilitator verify/settle, monetize endpoints
Base — Basenames 3 Forward/reverse resolution (mainnet‑verified) + registration tx
Base App / Farcaster Mini Apps 3 farcaster.json manifest, fc:miniapp embed, validation
ERC‑8004 Trustless Agents 3 Agent identity/AgentCard resolution (mainnet‑verified) + card generator
Multi‑protocol portfolio + strategy plans + backtest 6 + 1 One‑shot snapshot across 4 protocols
Tron (TVM) — reads / research / risk / transfers / SunSwap / JustLend + agent wallet 14 Non‑EVM; same key as the EVM agent wallet; deterministic tron policy gate
Agent wallet (encrypted EOA + admin policy gate) 7 LLM cannot bypass policy
Utility (credit estimate, balance) 2
Total 154

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.

Tool What it does
chaingpt_x402_decode Decode an x402 402 challenge / X‑PAYMENT header into human terms before paying
chaingpt_x402_build_payment Build the UNSIGNED EIP‑3009 transferWithAuthorization typed data; return the X‑PAYMENT header once signed
chaingpt_x402_facilitator Call a facilitator — supported / verify / settle
chaingpt_x402_create_requirements Generate PaymentRequirements + a 402 body to monetize your own API
chaingpt_base_resolve_name Resolve name.base.eth ↔ address (forward + reverse) — verified live on Base mainnet
chaingpt_base_name_availability Is a Basename available + its price for N years
chaingpt_base_register_name_tx UNSIGNED Basename registration tx (sets addr + reverse record); mainnet gated
chaingpt_miniapp_manifest Generate /.well-known/farcaster.json for a Base App / Farcaster Mini App
chaingpt_miniapp_embed Generate the fc:miniapp (+ legacy fc:frame) share embed meta tag
chaingpt_miniapp_validate Validate a Mini App manifest against the spec
chaingpt_erc8004_resolve_agent Resolve an ERC‑8004 agent → owner + AgentCard — verified live on Base mainnet
chaingpt_erc8004_registries Canonical Identity/Reputation registry addresses (the 0x8004… singletons)
chaingpt_erc8004_agentcard Generate 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)

Tool What it does
chaingpt_chat Ask the Web3 AI chatbot — crypto‑native LLM with live on‑chain data
chaingpt_chat_with_context Branded chatbot with company / token context injection
chaingpt_chat_history Retrieve past conversations by session id
chaingpt_nft_generate_image · _enhance_prompt · _generate_and_mint · _get_chains Generate AI art, mint on 22+ chains
chaingpt_audit_contract AI security audit with scored report
chaingpt_generate_contract Natural language → production Solidity
chaingpt_news_fetch · chaingpt_news_categories Crypto news with category + token filters
chaingpt_estimate_credits · chaingpt_check_balance Cost + balance utilities

Web3 toolkit (14 tools)

Across 12 chains: ethereum, base, arbitrum, optimism, polygon, bsc, avalanche, blast, linea, scroll, solana, tron. (Solana + Tron are non‑EVM: research/risk resolve via their tron/solana provider slugs; the dedicated chaingpt_tron_* / chaingpt_solana_* tools are the full on‑chain surface.)

Tool What it does Backend
chaingpt_wallet_balances · _positions · _pnl Multi‑chain native + ERC‑20 balances, DeFi positions, realized + unrealized P&L Moralis (opt) + RPC
chaingpt_research_token · _pairs · _trending Price, liquidity, volume, all trading pairs, trending tokens DexScreener
chaingpt_risk_token · _honeypot · _address · _contract_source Honeypot / mintable / proxy flags, buy + sell simulation, sanctions / phishing check, verified source code GoPlus + Honeypot + Etherscan v2
chaingpt_onchain_tx · _address · _gas · _block Decode any tx, recent activity, multi‑chain gas oracle, block info Etherscan v2 + RPC

AI‑enriched composed tools

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

Tool What it does
chaingpt_intel_token One call → DexScreener + GoPlus + ChainGPT news + AI signal. The "research this token" tool. ~1 credit.
chaingpt_intel_wallet Portfolio + 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.

Tool What it does
chaingpt_deploy_compile Solidity 0.8.x → bytecode + ABI + warnings
chaingpt_deploy_estimate Preview gas cost on the target chain
chaingpt_deploy_build_tx Refuses mainnet without acknowledgeMainnet: true
chaingpt_deploy_verify · _verify_status Submit 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.

Tool Backend
chaingpt_dex_quote · _build_swap_tx · _approve_tx OpenOcean v4 (EVM)
chaingpt_dex_jupiter_quote · _jupiter_build_swap_tx Jupiter v6 (Solana)
chaingpt_dex_1inch_quote · _1inch_build_swap_tx 1inch v6 (EVM, key‑gated)
chaingpt_dex_cow_quote · _cow_create_order CoW 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.

Tool What it does
chaingpt_defi_aave_health · _supply_tx · _borrow_tx · _repay_tx · _withdraw_tx Aave V3 on 7 chains
chaingpt_defi_lido_stake_tx Stake native ETH → stETH on Lido
chaingpt_defi_eigenlayer_deposit_tx Restake stETH / rETH / cbETH on EigenLayer
chaingpt_defi_pendle_markets · _market Pendle yield‑strip discovery — fixed APY, implied APY, YT, maturity
chaingpt_defi_morpho_markets · _vaults · _user Morpho 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.

Tool What it does
chaingpt_hl_markets · _mids · _orderbook · _account · _fills · _funding Read HL market data + account state
chaingpt_hl_place_order_payload · _cancel_order_payload · _update_leverage_payload EIP‑712 signed intents — user wallet finalizes
chaingpt_drift_markets · _market · _orderbook · _funding · _user Read Drift perp markets, orderbook, funding, user account

Polymarket prediction markets (6 tools)

Tool What it does
chaingpt_pm_markets · _market · _orderbook · _trades Discover markets + read live data
chaingpt_pm_create_order · _create_neg_risk_order EIP‑712 signed CTF / Neg‑Risk order intents

Cross‑chain bridging (3 tools)

Tool What it does
chaingpt_bridge_quote · _build_deposit_tx · _status Across Protocol v3 across 10 EVM mainnets

Solana lending (4 tools, read‑only)

Tool What it does
chaingpt_defi_marginfi_banks · _account Marginfi v2 banks + user account
chaingpt_defi_kamino_markets · _vaults Kamino markets + automated yield vaults

Tron (TVM) — 14 tools

Non‑EVM chain (TVM). The agent's Tron account uses the same secp256k1 key as the EVM agent wallet (only the address encoding differs), so there is no separate keystore. Custody‑free builders return an UNSIGNED tx (sign in TronLink); the agent wallet signs autonomously behind a fail‑closed tron policy. OpenOcean/1inch/Moralis don't support Tron, so DEX routing is SunSwap‑direct. See reference/tron.md.

Tool What it does
chaingpt_tron_validate_address · _balances · _token_balance · _account_resources · _tx_info Reads: address forms, TRX + TRC‑20 balances, bandwidth/energy, tx receipt
chaingpt_tron_research_token · _risk_token DexScreener pairs + GoPlus security (slug tron)
chaingpt_tron_build_transfer_tx · _build_trc20_transfer_tx Unsigned TRX + TRC‑20 transfers (custody