comfy.fun MCP (@0g-axion/comfy-mcp)

Explore 0G tokens, quote swaps, and build unsigned transactions.

Connect your agent to comfy.fun on 0G mainnet to explore tokens, quote swaps, check creator fees, browse agent tasks and compute, and build unsigned transactions for your wallet. The server holds no keys and never signs or submits transactions. Figures it cannot read come back as unknown, never as zero. Connect over stdio or streamable HTTP.

Safety

• Read-only RPC and indexer access.

• Holds no private keys; never signs or sends transactions.

• Builders return unsigned transactions for you to review and sign in your own wallet.

• Unreadable figures are returned as unknown, never zero.

• Token names, listings and task text are third-party content; the server tells clients to treat them as data, never as instructions.

• Builders require an explicit slippage (at most 5000 bps, like the web app); review it before signing.

Related MCP server: Trust Vault MCP Server

Overview

MCP server for reading Comfy and building unsigned transactions. An agent (Claude Code, Codex, Cursor, any MCP client) can read the market the same way the web app does. Fourteen tools read Comfy's engine REST, public indexer GraphQL and public 0G RPC (mainnet, chain 16661), or build unsigned transactions for an external wallet. The server holds no wallet key, never signs and never submits transactions. The owner-only comfy_jobs read can forward an opaque wallet session supplied through COMFY_SESSION. On comfy.fun today, the two task-board tools answer 503 task_board_closed; the table below marks them.

The package is scoped on purpose: the unscoped comfy-mcp on npm belongs to Comfy-Org (ComfyUI) and is not this project.

Add it to a client

# Claude Code
claude mcp add comfy -- npx -y @0g-axion/comfy-mcp@0.6.0

# Cursor: install the comfy.fun plugin from the Cursor Marketplace, or use the
# generic config below in ~/.cursor/mcp.json

# Codex CLI (~/.codex/config.toml)
# [mcp_servers.comfy]
# command = "npx"
# args = ["-y", "@0g-axion/comfy-mcp@0.6.0"]

Generic client config:

{
  "mcpServers": {
    "comfy": { "command": "npx", "args": ["-y", "@0g-axion/comfy-mcp@0.6.0"] }
  }
}

No configuration is needed: by default the server reads comfy.fun's engine and indexer. To read another deployment, set COMFY_ENGINE_ORIGIN and COMFY_INDEXER_GRAPHQL_HTTP.

Tools

The market tools read comfy's Infinity index through its public read operations, scoped to one deployment. A token that has never traded reports null price, change, volume, FDV and market cap: its opening price is not a measured market figure. comfy_tokens leaves out what the site's lists leave out (test launches, reserved tickers) and says how many in hidden; comfy_token still reads any of them by address. Tokens of the retired index are not read: every token on comfy.fun is on the Infinity index.

comfy_tasks and comfy_task relay the engine's 503 task_board_closed while the task board is closed.

A figure an upstream cannot supply comes back as unknown, never as zero, and an upstream that is down is a live: false answer, not an empty list. A deployment the index does not know is deployment_unknown, and a newest-first read that cannot be read whole is window_overflow, never a stale page. More in the MCP docs.

Transports and configuration

npx -y @0g-axion/comfy-mcp@0.6.0                    # stdio (for MCP client configs)
npx -y @0g-axion/comfy-mcp@0.6.0 --http --port 8931       # streamable-http at POST /mcp, loopback only

--port defaults to COMFY_MCP_PORT, then 8931. Base URLs come from COMFY_ENGINE_ORIGIN and COMFY_INDEXER_GRAPHQL_HTTP and default to comfy.fun's (https://warmth.comfy.fun, https://indexer.comfy.fun/v1/graphql). COMFY_INFINITY_DEPLOYMENT names the deployment the market tools read, as chainId:manager:splitter; it defaults to comfy.fun's, and a malformed value falls back to it. COMFY_MCP_TIMEOUT_MS bounds each upstream request (default 5000, 100 to 60000). COMFY_SESSION is optional for all public tools and required for an owner-authorized comfy_jobs result. A session for a different wallet than the one asked about is relayed as the engine's 403 wallet_mismatch, not as sign-in advice. The session is honoured on stdio only: the --http listener authenticates no client, so it never forwards COMFY_SESSION and comfy_jobs there answers the engine's 401 sign_in_required. To get a session, run comfy auth login from the comfy CLI with WARMTH_API=https://warmth.comfy.fun. It signs the engine's challenge with the wallet's PRIVATE_KEY (a wallet whose key you cannot export cannot sign in this way) and stores a 24-hour session in ~/.config/comfy/sessions.json; pass that session as COMFY_SESSION, and keep it out of logs and committed client configs.

Quotes and unsigned transactions (0.6.0)

COMFY_RPC_URL overrides the public repository default https://evmrpc.0g.ai. It must use HTTPS; HTTP is allowed only for localhost, 127.0.0.1, or [::1]. The configured RPC is trusted for quote amounts and therefore min_out; chain and payload checks do not prove its answers are accurate. Chain tools verify chain 16661 and currently support the committed production Infinity generation only. A different COMFY_INFINITY_DEPLOYMENT returns unsupported_deployment; changing the indexer URL does not authorize a different router. All contract reads in a result use one block. RPC timeouts, wrong-chain responses and malformed results are named failures, never zero balances.

Amounts are exact decimal strings, not floating-point numbers. Like the web trade path, swaps support native 0G / 18-decimal tokens. The quote defaults to 100 basis points slippage; both quotes and builders cap it at 5000 bps (50%), matching the web app. Builders require an explicit integer in 0–5000. Minimum output rounds up, as in the web SDK. Fee disclosure uses the live hook and per-pool FeeSplitter settings; hook bps and core pips have different bases and are not summed. A quote still includes the hook charge if optional fee reads fail: fees: null and fees_status name the failed RPC source. Price impact compares quoted output with the same-block pool spot price and explicitly includes fees and curve movement; it is not isolated curve impact. An unreadable spot price yields null with price_impact_status.

Unsigned builders return {chainId, to, data, value, description, approvals_needed}. value is decimal wei, and calldata is hex. Swap output goes to recipient, while the eventual sender supplies the input. Sell approvals are conditional prerequisites, not a claim about that sender's allowances: first approve the exact token amount to Permit2, then approve the router in Permit2 until the swap deadline. Both are unsigned. The swap uses an empty Permit signature, matching the SDK's allowance-based path. Approval and swap submission belong to the external wallet. Swap deadlines are ten minutes from the read block; stale quotes should be rebuilt.

Creator fees are public ledger data, not an authenticated ownership claim. A token-only request returns all its creator/recipient wallet legs. A wallet filter uses current bindingOf results, including co-recipients. Wallet-only requests inspect at most 100 indexed tokens in ascending deployment:address id order: by address, not launch time. Tokens outside this window are not searched; use token to read one directly. Scans use at most eight concurrent pool workers and at most eight outstanding pool-read RPC calls (including response bodies). Index page fetches and the head read are separate. A 20-second overall budget includes index discovery and RPC. scanned counts discovered token rows, including excluded rows; it is not the number of successful pool reads. failed lists {token, reason} for unusable or unfinished pools, including missing or malformed indexed pool records. A pool failure or deadline sets complete: false and retains successful pools; scan_outcome is ok, partial, or timeout. If the deadline expires before a block is read, block_number is null; if token discovery has not finished, failed is empty because addresses are still unknown. complete also stays false when the index window is truncated. These results are never lifetime totals. Token-specific failures remain tool errors. claimable means credited now; pending is the separately projected next sweep at the current split. Native and token amounts each include exact raw strings; unknown token decimals yield formatted: null.

Launch inputs are creator, name, symbol, salt (32-byte hex), opening_tick (a multiple of 60), and terms with creator_tax_bps, delay_seconds, opening_bps, floor_bps, and decay_seconds. Optional fields are image, metadata, context, and recipients (up to 15 entries, each with identity, account_wallet, share_bps). The creator must be the eventual sender. The builder always uses the SDK's five-rung project ladder, enforces the live caps and 30-second minimum opening delay, binds the current config hash, and uses the live launch fee and a five-minute deadline. This is an ordinary token launch; agent registration, sponsorship and post-launch compute-share changes are separate flows.

Search uses InfinityTokens' existing allowlisted $where filter, escaping SQL wildcards in user text. scanned counts matching rows returned by the indexer (up to 1,000), not the total token population; truncated covers both this scan bound and the requested output limit. Test launches and reserved tickers follow the same exclusions as comfy_tokens. Before the output limit, scanned matches rank by exact address, exact symbol, exact name, symbol prefix, name prefix, then other matches, case-insensitively. Ties use descending liquidity_og, with null liquidity last.

Development

npm ci
npm test      # builds, then runs the test suite (Node 20+)

A few parity tests cross-check files in Comfy's main repository and are skipped here.

Security

See SECURITY.md for how to report a vulnerability.

License

MIT, see LICENSE.