# 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. Manual live-API smoke checks. [![npm version](https://img.shields.io/badge/version-1.22.2-blue?style=flat-square)](https://github.com/ChainGPT-org/chaingpt-claude-skill/releases) [![License: MIT](https://img.shields.io/badge/license-MIT-green?style=flat-square)](LICENSE) [![Tests](https://img.shields.io/badge/tests-491%20vitest%20%2B%2026%20mock%20%2B%2039%20live--smoke-brightgreen?style=flat-square)](#-testing) [![Live-API smoke](https://github.com/ChainGPT-org/chaingpt-claude-skill/actions/workflows/smoke.yml/badge.svg)](https://github.com/ChainGPT-org/chaingpt-claude-skill/actions/workflows/smoke.yml) [![MCP Tools](https://img.shields.io/badge/MCP_tools-154-blueviolet?style=flat-square)](#-mcp-server--154-tools) [![Claude Code](https://img.shields.io/badge/Claude_Code-skill-blueviolet?style=flat-square)](https://code.claude.com) [![TypeScript](https://img.shields.io/badge/TypeScript-strict-blue?style=flat-square)](https://www.typescriptlang.org/) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-orange?style=flat-square)](CONTRIBUTING.md) [Quickstart](#-quickstart) · [Why this exists](#-why-this-exists) · [How it works](#-how-it-works) · [Security model](#-security-model) · [MCP tools](#-mcp-server--154-tools) · [Agent Wallet](#-the-agent-wallet-dashboard) · [vs alternatives](#-how-this-compares) · [Docs](https://docs.chaingpt.org/dev-docs-b2b-saas-api-and-sdk)

--- ## ⚡ Install from a reviewed checkout Requires **Node.js 22.14+**, npm, Git, and [Claude Code](https://code.claude.com/docs/en/overview). Use a fresh checkout and review its revision and lockfile before installing: ```bash git clone https://github.com/ChainGPT-org/chaingpt-claude-skill.git cd chaingpt-claude-skill git log -1 --oneline # Review the checkout before continuing. Keep API keys and wallet secrets unset. npm ci --prefix mcp-server --omit=dev --ignore-scripts claude --plugin-dir "$PWD" ``` Verify `chaingpt` in `/mcp`. Supply optional credentials only after installation, as described in [Step 5](#step-5--set-your-api-key-optional-but-recommended). MCP startup never downloads packages or runs install scripts. Missing dependencies block startup. After changing revisions, review the new lockfile and repeat `npm ci` before launching Claude. Do not reuse dependency caches from an untrusted install. The marketplace copy does not include installed dependencies. Use the prepared local checkout above for this release; the former automatic first-launch install has been removed. Claude Code's [`--plugin-dir` option](https://code.claude.com/docs/en/plugins) loads this exact local directory for the session.
## 👀 60-second tour ![Agent wallet refuses an over-cap transfer](docs/demo/agent-wallet-refusal.gif) > 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: ```text 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: ... ``` ```text 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. ``` ```text 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](#-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](#-the-agent-wallet-dashboard) · `skills/scheduled-autonomy` · [Security model](#-security-model) | | **An agent builder** | `/agents` → `web3-researcher` / `defi-trader` | [MCP tools](#-mcp-server--154-tools) · `agents/` + `hooks/` · x402 + ERC-8004 skills | | **A Solidity dev** | "generate and audit an ERC-20" | [Templates](#-10-project-templates) · [Contract patterns](#-45-smart-contract-patterns) · deploy skill | ## 🆕 What's new **[v1.22](https://github.com/ChainGPT-org/chaingpt-claude-skill/releases/tag/v1.22.0)** Tron (TVM) integration — non-EVM chain at EVM/Solana parity (14 tools, reuses the EVM key, fail-closed `tron` policy, SunSwap + JustLend) · **[v1.19](https://github.com/ChainGPT-org/chaingpt-claude-skill/releases/tag/v1.21.0)** Solana signing parity (Ed25519 agent wallet, simulation-priced lamport caps) · **[v1.18](https://github.com/ChainGPT-org/chaingpt-claude-skill/releases/tag/v1.18.0)** local-only usage insights + self-healing CI · **[v1.17](https://github.com/ChainGPT-org/chaingpt-claude-skill/releases/tag/v1.17.0)** scheduled autonomy (set-and-forget DCA with a crash-safe execution journal) · **[v1.16](https://github.com/ChainGPT-org/chaingpt-claude-skill/releases/tag/v1.16.0)** daily velocity caps, shipped subagents, mainnet-guard hook · [all releases](https://github.com/ChainGPT-org/chaingpt-claude-skill/releases) ## ⚡ Quickstart — full step‑by‑step This walkthrough takes you from zero to a running dashboard. Install the reviewed dependencies before providing credentials. ### 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:** ```bash 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 . **Verify:** ```bash 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 — Clone and review Clone the repository into a new directory using the commands in [Install](#-install-from-a-reviewed-checkout). Check the commit and review `mcp-server/package.json` and `mcp-server/package-lock.json`. ### Step 3 — Prepare dependencies From the repository root, with API keys and wallet secrets unset: ```bash npm ci --prefix mcp-server --omit=dev --ignore-scripts ``` This installs the locked production dependencies without package lifecycle scripts. The reviewed `mcp-server/dist/` is included. To rebuild it yourself, install development dependencies with `npm ci --prefix mcp-server --ignore-scripts`, then run `npm run build --prefix mcp-server`. ### Step 4 — Load the prepared plugin From the repository root: ```bash claude --plugin-dir "$PWD" ``` Keep this option when starting future sessions. Verify the server through `/mcp`. If startup reports missing dependencies, repeat Step 3 in this same checkout. ### 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`): ```bash 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 . 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: > ```bash > 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. ```bash 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 ` | Register a custom marketplace | | `/plugin install @` | 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 | |---|---| | Startup blocked: dependencies are not installed | Run Step 3 in the reviewed local checkout, then launch with `claude --plugin-dir` pointing to that directory. | | Marketplace install does not connect the MCP server | Use the prepared local checkout in Steps 2–4; marketplace copies do not contain dependencies. | | `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. |

Alternative install: MCP server only (skip the skills layer)

If you want only the MCP tools — no auto-loaded skills or reference docs — add the server directly to your Claude Code settings: ```json { "mcpServers": { "chaingpt": { "command": "node", "args": ["/absolute/path/to/chaingpt-claude-skill/mcp-server/launch.mjs"], "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](#-the-agent-wallet-dashboard) 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:** ```bash # 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** | |

Expand the full per-category tool reference

### 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](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‑free, mainnet‑ack‑gated) | | `chaingpt_tron_dex_sunswap_quote` | SunSwap swap quote (V2 `getAmountsOut`) | | `chaingpt_tron_lend_justlend_account` · `_lend_justlend_build_tx` | JustLend liquidity read + unsigned approve/supply/withdraw/borrow/repay | | `chaingpt_agent_wallet_tron_address` · `_sign_and_send` | Agent's Tron address + autonomous build→sign→broadcast under the `tron` policy gate | ### Portfolio + strategy plans + backtest (7 tools) | Tool | What it does | |---|---| | `chaingpt_portfolio_snapshot` | Fan‑out parallel to HL + PM + Morpho + Drift for one user | | `chaingpt_strategy_dca` · `_grid` · `_funding_arb` · `_copy_trade` | Strategy template planners | | `chaingpt_strategy_save_plan` · `_load_plan` · `_list_plans` · `_delete_plan` | Persist strategy plans to `~/.chaingpt-mcp/plans/` | | `chaingpt_backtest_grid` | Replay 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](#-the-agent-wallet-dashboard) for the threat model and admin flow. | Tool | What it does | |---|---| | `chaingpt_agent_wallet_init` | AES‑256‑GCM encrypted keystore, scrypt KDF | | `chaingpt_agent_wallet_address` · `_status` · `_balances` · `_policy` | Read‑only views | | `chaingpt_agent_wallet_sign_and_send` | **Only fund‑moving tool.** Policy gate runs deterministically; refuses with reason on any violation. | | `chaingpt_agent_wallet_serve_ui` | Start the localhost admin dashboard on 127.0.0.1:8787 | ### Optional API keys The plugin works without these but unlocks more if present: | Env var | Unlocks | Get one | |---|---|---| | `MORALIS_API_KEY` | Full multi‑chain ERC‑20 scan + DeFi positions + P&L | https://moralis.io (25k req/month free) | | `ETHERSCAN_API_KEY` | Higher Etherscan rate limit (Etherscan v2 covers every major EVM chain) | https://etherscan.io/myapikey (free) | | `ONEINCH_API_KEY` | 1inch v6 aggregator routing | https://portal.1inch.dev | | `TRON_PRO_API_KEY` | Higher TronGrid rate limit for Tron tools (mainnet keyless is throttled) | https://www.trongrid.io (free) | | `TRON_RPC_URL` | Override the Tron node host (mainnet/Shasta/Nile). Agent‑wallet signing refuses a non‑TronGrid host. | — |

## 📦 ChainGPT products covered | Product | What it does | Cost | |---|---|---| | **Web3 AI Chatbot & LLM** | Crypto‑native LLM with live on‑chain data, Nansen Smart Money, 33+ chains | 0.5 credits | | **AI NFT Generator** | Text‑to‑image + on‑chain minting across 22+ chains, 4 AI models | 1–14.25 credits | | **Smart Contract Generator** | Natural language → production Solidity | 1 credit | | **Smart Contract Auditor** | AI vulnerability detection with scored audit reports | 1 credit | | **AI Crypto News** | Real‑time AI‑curated news, 24 categories, RSS feeds | 0.1 credits | | **AgenticOS** | Open‑source autonomous X/Twitter AI agents | 1 credit/tweet | | **Solidity LLM** | Open‑source 2B‑param model for Solidity code generation | Free | Plus **SaaS & Whitelabel** references — Launchpad, Staking, Vesting, Telegram bots. **1 credit = $0.01 USD · 15% bonus when paying with $CGPT.**
## 📋 10 Project Templates | Template | Stack | ChainGPT products | |---|---|---| | Web3 AI Chatbot | Express + TypeScript | LLM | | NFT Minting Service | Node.js | NFT Generator | | Contract Audit CI/CD | GitHub Actions | Auditor | | Crypto News Dashboard | Vanilla JS | News API | | AI Twitter Agent | Node.js | AgenticOS | | **NFT Marketplace** | Next.js + wagmi | NFT + LLM + Auditor + News | | **DeFi Dashboard** | React + Recharts | LLM + News + Auditor | | **Next.js Chatbot** | Next.js 14 App Router | LLM | | **React Native Wallet** | Expo + React Native | LLM + NFT | | **Nuxt News App** | Nuxt 3 SSR | News API |
## 🔐 45+ Smart Contract Patterns Audited, production‑ready Solidity patterns Claude composes from instead of generating from scratch: | Category | Count | Examples | |---|---:|---| | **ERC‑20 Tokens** | 10 | Basic, burnable, taxable, reflection, governance, multi‑chain | | **NFTs** | 10 | ERC‑721, 721A, lazy mint, soulbound, dynamic, ERC‑1155, revenue‑sharing | | **DeFi** | 10 | Staking, vesting, bonding curve, AMM, flash loans, ERC‑4626 vault | | **Governance** | 5 | Governor, multi‑sig, DAO treasury, delegation | | **Security** | 10 | Access 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 | Item | Price | |---|---| | **1 credit** | $0.01 USD | | **Pay with $CGPT** | 15% bonus credits | | **Mock server** | Free, unlimited (`http://localhost:3001`) | | **Manual live-smoke run** | Free (uses public endpoints; ChainGPT‑side calls use a smoke key) | | **Web3 AI Grant** | Up to **$1,000,000** for projects built on ChainGPT — [grant page](https://www.chaingpt.org/web3-ai-grant) | | **Pad Innovation Grant** | Up to **$25,000** for hackathon / pilot projects — [grant page](https://docs.chaingpt.org/dev-docs-b2b-saas-api-and-sdk/chaingpt-pad-innovation-grant-program) | Per‑product credit costs are in [reference/pricing.md](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. ```bash cd mock-server # from the reviewed repository checkout npm ci --ignore-scripts && 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 ```bash ./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`](TESTING.md) for the full reference. | Layer | Pass count | Network | |---|---|---| | `validate` (structural / frontmatter checks) | 159 | none | | `typecheck` (`tsc --noEmit` for both servers) | clean | none | | `mcp-test` (vitest — handlers, policy gate, signing, schemas) | **491** | none | | `mock-test` (vitest — mock‑server endpoints via supertest) | 26 | none | | `examples` (`node --check` + `python3 -m ast`) | every file | none | | `smoke` (live mainnet APIs) | 39 | yes | CI runs the first four on every push and PR ([`.github/workflows/ci.yml`](.github/workflows/ci.yml)). Live smoke is manual, uses public endpoints with a fixture key, and cannot write to the repository or open issues. Autonomous self-heal is disabled. **The contract: every PR that adds a tool or behavior must add tests in the same PR.** See [`TESTING.md`](TESTING.md#adding-tests-for-a-new-capability).
## 📊 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 skill** | Goat SDK (Crossmint) | Coinbase AgentKit | MetaMask Snaps + MCP | Heurist | |---|---|---|---|---|---| | **Surface** | 154 MCP tools across 11 categories incl. perps + prediction markets + cross‑chain + agent wallet | Plugin per protocol (extensible) | EVM swap + on‑chain + Base‑native | Wallet + LLM bridge | Image gen + LLM marketplace | | **Custody model** | User‑sovereign default + bounded agent EOA with admin policy gate | User‑sovereign | User wallet (CDP) or smart wallet | MetaMask signs everything | N/A (no signing) | | **Mainnet safety** | Mandatory `acknowledgeMainnet: true` + audit‑before‑deploy gate | Per‑plugin | Default mainnet | MetaMask UI confirmation | N/A | | **AI enrichment** | DexScreener + GoPlus + News + AI signal composed into one call | None native | None native | None native | Image + LLM only | | **Cost transparency** | Per‑tool credit costs surfaced; mock server free | LLM tokens only | Gas only | Gas only | Per‑model | | **Solidity codegen + audit** | Native (`chaingpt_generate_contract` + `chaingpt_audit_contract`) | No | No | No | No | | **Prediction markets** | Polymarket native | No | No | No | No | | **Perps** | Hyperliquid (signed) + Drift (read) | Add‑on | No | No | No | | **Spending limits under autonomy** | Per‑tx cap + rolling‑24h spend/tx‑count caps enforced in code the LLM can't modify | No | Smart‑wallet policies (CDP) | Per‑tx MetaMask approval | N/A | | **On‑chain caps (ERC‑4337 session keys)** | Yes — designed so the chain enforces per‑token caps at validation _(beta: addresses verified on Base Sepolia; full live proof pending)_ | No | No | No | No | | **Scheduled execution safety** | Crash‑safe execution journal (re‑runs can't double‑buy) | No | No | No | No | | **Shipped agents** | 3 (researcher / auditor / trader) with tuned guardrails | No | No | No | No | | **Test harness** | 6 layers + manual live smoke + human-reviewed repairs | Per‑plugin | Examples only | Snap testing | None | | **License** | MIT | MIT | Apache‑2 | MIT | Various | **Where this wins:** breadth (154 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

Click to expand

``` 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/ # 24 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 │ ├── tron/SKILL.md # Tron (TVM) — TRC-20, SunSwap, JustLend, agent-wallet signing │ ├── 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 — 154 tools, 491 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) - [x] Complete API reference for all 7 ChainGPT products - [x] **154 MCP tools** across ChainGPT AI, EVM + Solana DEX (OpenOcean · 1inch v6 · CoW · Jupiter), DeFi (Aave · Lido · EigenLayer · Pendle · Morpho), Tron (TRC‑20 · SunSwap · JustLend · agent‑wallet signing), perps (Hyperliquid · Drift), prediction markets (Polymarket), cross‑chain (Across), Solana lending (Marginfi · Kamino), multi‑protocol portfolio snapshot, strategy plan persistence + backtest - [x] **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) - [x] **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 - [x] 10 project templates including multi‑product compositions - [x] 45+ audited Solidity patterns - [x] Mock server for zero‑credit development (26 endpoint tests) - [x] **Unified test harness** — `./scripts/test-all.sh` runs six layers. 491 vitest + 26 mock + 159 validate + 39 live‑API cases - [x] **Daily live‑API smoke CI** — catches upstream drift within 24h, opens a labeled GitHub issue on failure - [x] Migration guides (OpenAI, Alchemy, custom) - [x] Cost optimization & wallet integration docs - [x] **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. - [x] **SSE streaming demo** — `examples/sse/` wraps the General Chat stream as Server‑Sent Events with a browser EventSource client. - [x] **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](CONTRIBUTING.md) for guidelines. ```bash # Validate your changes before submitting bash scripts/validate.sh ```
## 📄 Prerequisites | Requirement | Link | |---|---| | **ChainGPT API Key** | [app.chaingpt.org](https://app.chaingpt.org) — connect a wallet to sign up | | **API Credits** | [Buy credits](https://app.chaingpt.org/addcredits) — 1,000 credits = $10 | | **Claude Code** | [code.claude.com](https://code.claude.com) |
## 🔗 Links

[Developer Docs](https://docs.chaingpt.org/dev-docs-b2b-saas-api-and-sdk) · [API Dashboard](https://app.chaingpt.org/apidashboard) · [Pricing](https://app.chaingpt.org/pricing) · [Web3 AI Grant ($1M)](https://www.chaingpt.org/web3-ai-grant) · [Pad Innovation Grant ($25K)](https://docs.chaingpt.org/dev-docs-b2b-saas-api-and-sdk/chaingpt-pad-innovation-grant-program) [Solidity LLM on HuggingFace](https://huggingface.co/Chain-GPT/Solidity-LLM) · [AgenticOS on GitHub](https://github.com/ChainGPT-org/AgenticOS) · [Book a SaaS Demo](https://calendly.com/saaswl/demo)

## 📜 License MIT — see [LICENSE](LICENSE) for details. ---

**Built by [ChainGPT](https://www.chaingpt.org)** — AI Infrastructure for Web3 If this skill saved you time, consider giving it a ⭐