Build with AI
Building a product on Chain Daddy? Start with Build your product on Chain Daddy: the rates, credit for what your app brings, the referral share and your quota.
An AI agent can put a game, app or site on crypto with Chain Daddy: find or launch a token, sell items for it, sign players in with their wallet, and check purchases on your server. Give it: the plugin (what to do and the mistakes to avoid), the MCP servers (tools), and the docs.
Your agent does not need your private key or seed phrase. Anything that moves money or launches a token, it prepares and you sign.
Install the plugin
The chaindaddy plugin adds skills your agent loads when a task needs them, and connects both MCP servers below. Its source is public at gitlab.com/opencrown/chaindaddy-plugins.
Claude Code
claude plugin marketplace add https://gitlab.com/opencrown/chaindaddy-plugins.git
claude plugin install chaindaddy@chaindaddyCodex
codex plugin marketplace add https://gitlab.com/opencrown/chaindaddy-plugins.git
codex plugin add chaindaddy@chaindaddyCursor: add the remote server below, and copy the skills into ~/.cursor/skills:
git clone --depth 1 https://gitlab.com/opencrown/chaindaddy-plugins.git ~/.chaindaddy-plugins
mkdir -p ~/.cursor/skills && cp -R ~/.chaindaddy-plugins/plugins/chaindaddy/skills/* ~/.cursor/skills/| Skill | Your agent uses it to |
|---|---|
add-crypto-to-your-game | Walk the whole path: token, store, sign-in, server checks, test store first |
sell-items-in-your-app | Run a store: items, orders, delivery, rewards, webhooks |
sign-in-with-chain-daddy | Add Sign in with Chain Daddy to your site or app |
verify-receipts-and-sessions | Verify receipts, session tokens and webhooks on your server |
build-a-crown-app | Build, test and publish an app for coin pages |
launch-a-token | Prepare a launch for you to sign |
find-and-check-a-token | Find a token and tell the registered one from copycats |
check-token-health | Read health scores and what keeps a registration |
export-a-listing | Prepare listing-site fields |
In Claude Code the plugin also guards your wallet. It refuses any tool call that carries a recovery phrase, private key or Solana keypair, and it asks you before any command that sends a transaction on a mainnet. /chaindaddy store opens a live pane on your store, your test store first, as orders and webhook deliveries come in. The pane appears once mods are turned on in your Claude Code. Details are in the plugin's README.
Connect the remote MCP server
https://api.chaindaddy.io/mcp gives any AI app Chain Daddy's tools and docs, with no key. It lists about thirty tools (search, tokens and registrations, launch venues, your token's holders, broadcasts, alerts and deals, your apps and store), and find_api_operations reaches every other operation in the API reference. Public reads need nothing; your own data asks you to sign in with Chain Daddy the first time, and changes ask you to allow them. Nothing it does moves money or tokens.
The server takes up to 300 requests a minute from each signed-in account, and 300 a minute per IP address from callers not signed in. Over that, a call answers with a JSON-RPC error saying so; wait a minute and try again.
Every tool that makes a change takes an optional idempotency_key. Give each change its own (a UUID), and send the same one again if you retry it after a timeout or a dropped connection: the retry gets the first answer back and nothing happens twice. The rules are those of the API's Idempotency-Key.
Every tool, with its input and an example, is in the MCP tools reference.
When the API refuses a call, the tool's error carries the API's own words and, for an app to act on, structuredContent.apiError: the HTTP status, the API's code, whether it is retryable, retryAfterSeconds and resetAt when the API says when, and the requestId to quote to support. A field the API does not give is null.
One of them, get_sign_in_snippet, hands your coding agent the code that adds Sign in with Chain Daddy to a site: give it the site's address (and a ticker, to also check that a visitor holds the coin) and it returns the four pieces to paste in, with the script tag pinned to the current build. Give it http://localhost:3000 instead and it returns the pieces that sign in on your own computer, with nothing hosted.
It also serves the plugin's skills, so an app that cannot install the plugin still gets them: as prompts where the app shows prompts, and through list_skills and read_skill everywhere else.
Start with get_my_account: who you are, your plan, the coin pages you run (as holder, manager or maintainer), and what needs you (an offer to answer, a coin page to register), each with its chaindaddy.io link. To launch or register a token, prepare_token_launch and prepare_token_registration hand you a filled-in chaindaddy.io link; you review it and confirm in your own wallet. A launch link can also fill in a team allocation: the share kept for the team, the people it is split with, and its schedules.
ChatGPT and Codex get a narrower server: none of the launch, registration, store, fee, plan, deal, airdrop, tip, trading or shop tools (get_my_account included), and none of the skills or docs pages about those. Each tool's page says when ChatGPT is not offered it.
If your company builds on these links, become a partner: links made for your app then carry your credit, and you earn a share of our fee on what they bring.
| App | How |
|---|---|
| Claude (web and desktop) | Settings → Connectors → Add custom connector, and paste the URL |
| ChatGPT | Turn on developer mode in settings, then add a plugin with the URL |
| Claude Code | claude mcp add --transport http chaindaddy https://api.chaindaddy.io/mcp |
| Codex | codex mcp add chaindaddy --url https://api.chaindaddy.io/mcp |
| Cursor | {"mcpServers":{"chaindaddy":{"url":"https://api.chaindaddy.io/mcp"}}} in .cursor/mcp.json, or the one-click link in the plugin's README |
An agent with its own wallet key
Software that holds a wallet's key can sign in by itself, with no browser and nobody to press Allow. It gets what a person's AI app gets on /mcp as that wallet, at the wallet's own plan and limits.
- Make a P-256 key for the agent. Every request carries a DPoP proof signed by it (
typ: dpop+jwt,alg: ES256,htm,htu,iat, a freshjti). POST https://api.chaindaddy.io/api/v2/oauth/agent/challenge(form:wallet, optionalagent_name) with a proof. The answer has anonceand amessage. Check that the message names your wallet and your key's thumbprint.- Sign
messageunchanged with the wallet (personal_signon EVM, ed25519 on Solana), thenPOST /api/v2/oauth/agent/token(form:nonce,signature) with a proof from the same key. The answer is anaccess_tokenfor one hour. There is no refresh token: sign in again. - Call
/mcpwithAuthorization: DPoP <access_token>and a proof for each request (htm: POST,htuthe/mcpURL,aththe token's SHA-256 in base64url).
The token opens /mcp only, and is useless without the agent's key. What needs a person is refused: API keys, client secrets, store administration and payouts. The wallet's owner sees the agent under Settings → Connected sites and can disconnect it. Both endpoints are in the API reference.
The local MCP server, for store work
The npm package @chaindaddy/mcp runs on your machine and has every tool, including the creator store (iap_*: items, orders, test store, keys, drops, webhooks). The plugin starts it for you; on its own:
claude mcp add chaindaddy-local -- npx -y @chaindaddy/mcp # Claude Code
codex mcp add chaindaddy-local -- npx -y @chaindaddy/mcp # Codex{ "mcpServers": { "chaindaddy-local": { "command": "npx", "args": ["-y", "@chaindaddy/mcp"] } } }Each release is built from public source with npm provenance: verify it with npm audit signatures in a project that installs it.
Every tool needs your account key, reads included (a Free key is enough). Set it in your shell, not in a chat:
| Variable | What |
|---|---|
CHAINDADDY_API_KEY | Your cd_live_… key from chaindaddy.io/_api: every call, and opening a store, items, store keys |
CHAINDADDY_IAP_KEY | A cd_iap_… store key, to act as your app server would |
Build against the test store first: orders are paid with one call, and no money moves.
Docs for agents
/llms.txt | An index of every page |
/llms-full.txt | Every page in one file |
/md/{path}.md | Any page as Markdown, e.g. /md/developer/store-and-rewards.md |
/openapi.yaml | The API |
The CLI takes --json --non-interactive on every command, for agents and CI.
Find us by name
Chain Daddy has two on-chain names, both held by its treasury. An agent that starts from either one ends up at the same site, the same llms.txt and the same MCP server as one that starts from chaindaddy.io.
| Name | Where | What it carries |
|---|---|---|
chaindaddy.eth | ENS, on Ethereum | url, the ENSIP-26 agent records agent-context, agent-endpoint[mcp] and agent-endpoint[web], a contenthash, and the signing keys below |
chaindaddy.sns | Solana Name Service | Url, IPFS and TXT records |
One text record on chaindaddy.eth is ours: io.chaindaddy.signing-keys. It holds the keys that sign what the API says, such as a receipt, as ed25519:<key> entries separated by a space. <key> is the raw public key in base64url, the same value as x in the key set. Accept a signature from any key listed.
The contenthash and the IPFS record point at a small set of files on IPFS: a page that sends every path on to the same path at chaindaddy.io, and a copy of llms.txt. So chaindaddy.eth.limo/llms.txt reads the same as chaindaddy.io/llms.txt.
The API, the MCP server and sign-in are only at chaindaddy.io addresses, so a page or an endpoint on any other address that asks you to sign in to Chain Daddy is not us.
Every verified coin has a name
A ticker with a verified page has ENS names: <symbol>.c.chaindaddy.eth, and <symbol>.<chain>.c.chaindaddy.eth for one chain, where <chain> is the chain in a page's address. A ticker is not unique, so each name is our pick for it, the same one <symbol>.crown.info shows: the most active verified page for that ticker.
| Name | Is |
|---|---|
fluxgp.c.chaindaddy.eth | our pick for the ticker across every chain |
fluxgp.base.c.chaindaddy.eth | our pick for the ticker on Base |
Any ENS library resolves them:
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { normalize } from 'viem/ens'
const client = createPublicClient({ chain: mainnet, transport: http() })
const name = normalize('fluxgp.base.c.chaindaddy.eth')
await client.getEnsAddress({ name }) // the wallet that holds the page
await client.getEnsText({ name, key: 'tokenAddress' }) // the coin's contract
await client.getEnsText({ name, key: 'url' }) // that coin's page on chaindaddy.io
await client.getEnsText({ name, key: 'chainId' }) // eip155:8453: the chain the pick is on| Ask the name for | You get |
|---|---|
| its address | the wallet that holds the coin's page. For a Solana coin, ask for coin type 501. |
text tokenAddress | the coin's contract or mint address |
text owner, tokenId, chainId, name, url, heartbeat, status | the holder, the page's id, its chain (CAIP-2), the coin's name, its page, and how active the page is |
Every answer describes the page the name picks. Ask a name with no chain in it for chainId to learn which chain that is.
A name also opens in a browser. Through an ENS gateway, https://fluxgp.base.c.chaindaddy.eth.limo goes to the coin's page on chaindaddy.io, and a browser that resolves ENS itself does the same from fluxgp.base.c.chaindaddy.eth.
What to know before you rely on one:
- A name can move from one wallet to another. It points at whoever holds the top-ranked verified page for that ticker right now, and the ranking follows activity (the page's heartbeat score, the
heartbeatrecord). When another page for the same ticker clearly overtakes it, the name resolves to that page's holder instead. So resolve the name each time you use it, do not store the address it gave you, and before you send money check thetokenAddressandchainIdrecords against the coin you mean. - Only a verified page can hold a name.
- A well-known coin's ticker has no name.
usdc,eth,wbtc, the big stablecoins and the largest coins do not resolve underc.chaindaddy.eth, whoever holds a page with that ticker. - It resolves to the holder's wallet, not the coin's contract. The contract is the
tokenAddressrecord. - It answers only while the page is verified. A page that is removed, or that stops being verified, stops resolving. viem returns
null; ethers raises an error. - The
urlrecord is the ticker's page.chaindaddy.io/fluxgp/baseshows the same pick the name resolves to. To link to one particular coin whatever happens to its ticker, add its address:chaindaddy.io/fluxgp/base?address=0x…. - Our API answers it. The name's resolver on Ethereum sends your library to
api.chaindaddy.ioand checks our signature on the answer (CCIP-Read), so these names resolve only while the API is reachable, and only in a library that supports CCIP-Read and wildcard names. Current viem, ethers and wallets do.