Chain Daddy

Step 2 of authentication. Exchanges a signed SIWE/SIWS message for a session bound to a backend JWT. Call get_auth_nonce first and embed the nonce in the message. Params: wallet_address (string), chain_type ('evm'|'solana'), signed_message (string), signature (string) Returns: {session_token: string, expires_at: string} Errors: INVALID_SIGNATURE, INVALID_ADDRESS, UNSUPPORTED_CHAIN, JWT_EXCHANGE_FAILED

Cancel a pending order. Only works on orders that have not been confirmed. Params: order_id (string), session_token (string) Returns: {cancelled: true} Errors: NO_SESSION, SESSION_EXPIRED, ORDER_NOT_FOUND, ORDER_EXPIRED, ORDER_ALREADY_CONFIRMED

Check if a wallet is eligible to claim a crown for a specific token. Verifies deployer, owner, admin, or majority holder status.

Get heartbeat status and activity score for a crown. Score below 60% means at-risk of reclaim.

Claim a crown for a specific token on a specific chain. Requires verified ownership. Returns an order action spec for inclusion in create_order. Params: symbol (string), chain (string), token_address (string), verification_method ('deployer'|'mint_authority'|'owner'|'majority_holder'), session_token (string) Returns: {order_action_spec: {type: 'claim_crown', params: {symbol, chain, token_address, verification_method, wallet}}} Errors: NO_SESSION, SESSION_EXPIRED, INVALID_CHAIN, INVALID_VERIFICATION_METHOD

Confirm and execute a pending order. Triggers all actions in the order. Cannot be undone. Params: order_id (string), session_token (string), idempotency_key (string?) Returns: {results: [{action, status, tx_hash?, error?}], idempotency_key} Errors: NO_SESSION, SESSION_EXPIRED, ORDER_NOT_FOUND, ORDER_EXPIRED, ORDER_ALREADY_CONFIRMED

Create a pending order with one or more actions. Returns order details with pricing and gas estimates. Order expires after 5 minutes. Params: actions (array of {type, params}), session_token (string), idempotency_key (string?) Returns: {order_id, summary, total_cost, gas_estimates, expires_at, idempotency_key} Errors: NO_SESSION, SESSION_EXPIRED, INVALID_ACTIONS, VALIDATION_ERROR

Deploy a single token on a single chain. Validates parameters and returns an order action spec for inclusion in create_order. Params: name (string), symbol (string), chain (string), supply (number), decimals (number), mintable (boolean), burnable (boolean), session_token (string) Returns: {order_action_spec: {type, params}} Errors: NO_SESSION, SESSION_EXPIRED, VALIDATION_ERROR, RATE_LIMITED

Generate listing data formatted for aggregator platforms (CMC, CoinGecko, DEX Screener, TokenList).

Find inactive crowns that are eligible for reclaim. All params optional. Params: symbol (string?), chain (string?), min_market_cap (number?) Returns: {inactive_crowns: [{symbol, chain, owner_address, last_activity, heartbeat_score, reclaim_cost}]} Errors: API_ERROR

Generate a listing for one aggregator format using crown data. Params: crown_id (string), format ('coingecko'|'coinmarketcap'|'dexscreener'|'tokenlist') Returns: {listing_data: object, missing_fields?: string[]} Errors: CROWN_NOT_FOUND, INVALID_FORMAT, API_ERROR

Step 1 of authentication. Fetches a server-issued nonce the caller must embed in the SIWE/SIWS message before signing. Params: none Returns: {nonce: string} Errors: API_ERROR

Get detailed information about a specific crown by ID. Params: crown_id (string) Returns: {symbol, chain, owner, manager, heartbeat_score, status, metadata, days_in_grace, penalty_deadline} Errors: CROWN_NOT_FOUND, API_ERROR

Find the tokens a wallet made on a chain (deployed, owns, or launched) that are not registered yet, and how it qualifies for each. Useful for finding tokens you can claim.

Get holder concentration and adversarial-label stats for a crown. Sourced from /api/v2/registration/{id}/holders; data refreshes daily. Params: crown_id (number) Returns: text report with totalHolders, top10/50/100/200 concentration, walletsForHalf, and Mobula label counts (snipers/bundlers/insiders/sandwich) plus suspiciousRatio. Errors: CROWN_NOT_FOUND, NO_DATA, API_ERROR

Get what an order costs, as the order will charge it. mode 'create' (default): a new token on each chain, its registration included. mode 'claim': registering a token that already exists on each chain (free for an OG token when symbol and address are given). All params optional. Two or more chains take the 10% multi-chain bundle discount, already subtracted from total_usd. Params: chains (string[]?), mode ('create'|'claim'?), symbol (string?), address (string?), bundle_type (string?), wallet_address (string?) Returns: {items: [{chain, type, fee_usd, gas_estimate}], discounts: [{type, description, amount_usd}], total_usd: number} Errors: API_ERROR

Get AI-powered recommendations for optimizing crown profile, heartbeat, and listing readiness.

Get the current session status for a session token. Returns authentication state, wallet, chain type, and expiry. Params: session_token (string) Returns: {authenticated: true, wallet: string, chain_type: 'evm'|'solana', expires_at: string} or {authenticated: false} Errors: none (always returns a result)

Get detailed information about a token on a specific chain including crown status, market data, and metadata.

Add wallets to a drop's recipient list (push drops, or an allowlist). Pass wallets, or csv text with one wallet per line. Params: store_id, drop_id, wallets?, csv?, session_token?, idempotency_key? Returns: {ok, idempotency_key, added: number, invalid: string[]} Errors: INVALID_PARAMS, NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_404

Award an award-mode drop to a wallet (the user reached a milestone). The drop's caps and window are enforced. Store key scope: rewards:award. Params: store_id, drop_id, wallet, session_token?, idempotency_key? (use one per milestone so a retry never awards twice) Returns: {ok, idempotency_key, …award result} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_404, HTTP_409 (cap reached / drop not active)

Consume units of a consumable a wallet holds (the user spent a credit). Atomic: fails without change when the wallet holds fewer. Store key scope: entitlements:write. Params: store_id, wallet, sku, quantity, session_token?, idempotency_key? Returns: {ok, idempotency_key, entitlement: Entitlement} Errors: INSUFFICIENT_QUANTITY (409), NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_404

Create a drop (a reward of items). Modes: claim (a link holders claim from), push (delivered to a recipient list when activated), award (your server awards it with iap_award, caps enforced). Audience is a rule (e.g. holders of at least X tokens). Drops start as drafts; activate with iap_set_drop_status. Store key scope: drops:write. Params: store_id, drop ({name, mode, items: [{sku, quantity}], audience?, allowlistOnly?, maxClaims?, perWalletLimit?, startsAt?, endsAt?, description?, imageUrl?}), session_token?, idempotency_key? Returns: {ok, idempotency_key, drop: Drop} (drop.slug is the claim link id) Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_400

Create an order for a user — the white-label path: your server sells from your app's own store with a store key (scope orders:write). The order locks the price, payees and a deadline (about 20 minutes) and carries `payment`: EVM {kind:'evm', chainId, checkout, order:{orderId, token, payees, amounts, deadline}, total, permit, calls?: [{to, data, value}] to send in order, permitTypedData?} or Solana {kind:'solana', cluster, transaction (base64 unsigned), reference, staticKey, memo}. The user's wallet pays; your client then posts the tx hash to /api/v2/iap/orders/{id}/submit, and the order turns confirmed at confirmation depth (poll iap_get_order or take the iap.order.confirmed webhook). Params: store_id, sku, quantity?, wallet (the user's wallet; required with a store key), app_account_token? (your own account id, echoed in the receipt), session_token?, idempotency_key? Returns: {ok, idempotency_key, order: Order} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED (store not live), HTTP_400, HTTP_404 (sku), HTTP_409 (sold out / per-wallet cap / rule not met), PRICE_UNAVAILABLE (a dollar-priced SKU paid in the token or the coin whose live price cannot be read reliably right now — stale, still warming up, or moving more than 15%; retry in a minute). The order carries currency (address), currencyKind ('token'|'native'|'usdc'), currencySymbol and currencyDecimals; `amount` is the exact locked amount in that currency. Paid in the chain's coin, `calls` holds only the pay call with value = total, and permit is null. A dollar-priced order also carries priceUsdMicros and usdPerToken (the dollar price of one whole unit of the currency; 1 for usdc).

Create a SKU. Types: consumable (a balance: coins, boosts), non_consumable (owned once: skins, cars), timed (expiry extended by durationSeconds × quantity: season pass), unlock (never sold; held while `rule` holds). No price = reward-only. Price in base units (`price`) or in dollars (`priceUsdMicros`, with optional per-unit `minPrice`/`maxPrice` bounds in base units), never both. `currency` is what the buyer pays in: 'token' (default; recommended with priceUsdMicros — a steady dollar price, paid in the creator's token), 'native' or 'usdc'. GET /api/v2/iap/config lists each chain's currencies. `grants` makes a bundle. `splits` pays up to 2 more wallets (3 on a launchpad token) a share of each sale. New SKUs are drafts unless status is 'active'. Store key scope: catalog:write. Params: store_id, sku ({sku, type, name, currency?, price?, priceUsdMicros?, minPrice?, maxPrice?, grants?, splits?, durationSeconds?, rule?, maxSupply?, maxPerWallet?, maxAppSpend?, saleStartsAt?, saleEndsAt?, status?, metadata?, description?, imageUrl?, sortOrder?}), session_token?, idempotency_key? Returns: {ok, idempotency_key, sku: Sku} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_400 (validation), HTTP_409 (sku key taken)

Create a store key (cd_iap_…) for your server: one store, only the scopes you list. The secret is returned ONCE — store it in the server's secrets, never in a client. Needs account credentials (a session or CHAINDADDY_API_KEY), never a store key. Params: store_id, name, scopes (catalog:write|orders:read|orders:write|entitlements:read|entitlements:write|drops:write|rewards:award|events:read|messages:send), session_token?, idempotency_key? Returns: {ok, idempotency_key, key: {id, name, prefix, scopes, createdAt, secret}} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_400

What a wallet holds in a store (owned items plus live unlocks), or — with sku — who owns a SKU. Pass exactly one of wallet or sku. Store key scope: entitlements:read. Params: store_id, wallet?, sku?, cursor? (owners list only), session_token? Returns: {storeId, wallet, entitlements: [{sku, type, name, quantity, expiresAt, source: 'ledger'|'unlock', firstGrantedAt}]} or {entries: [{wallet, quantity, expiresAt}], nextCursor} Errors: INVALID_PARAMS, NO_CREDENTIALS, IAP_PLAN_REQUIRED

Get one order: its locked quote, status, on-chain payment (txHash, payer, confirmations) and the signed receipt once confirmed. With store_id it reads the store's admin view (store key scope orders:read); without it, GET /api/v2/iap/orders/{id} (the buyer's own order, or any order of the store key's store) — what an app polls until status is 'confirmed'. Params: order_id (0x + 64 hex), store_id?, session_token? Returns: Order Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_404

Get the store's webhook and its last 20 deliveries, newest first. A delivery's status is pending, delivered, failed or exhausted (no more retries); anything missed can be caught up from iap_list_events. Store key scope: events:read. Params: store_id, session_token? Returns: {webhook: {id, url, events, active, createdAt, lastTriggeredAt} | null, deliveries: [{id, eventId, eventType, status, attempt, statusCode, error, createdAt, deliveredAt}]} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_404

Grant items to a wallet (a reward, a make-good, a server-side award). Items are off-chain and non-transferable. Store key scope: entitlements:write. Params: store_id, wallet, sku, quantity, reason?, session_token?, idempotency_key? Returns: {ok, idempotency_key, entitlement: Entitlement} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_400, HTTP_404 (unknown sku)

Read a store's event feed after a cursor: order.created/paid/confirmed/expired/refunded, order.mismatch (a payment named the order id but not its quote; the order is unchanged), order.duplicate_payment (the order was paid twice; the creator refunds the second), order.checkout_paid_again (a second order confirmed for a checkout session that was already paid; both delivered, and only the seller can send a payment back), order.reverted (a paid order undone by a chain reorg), entitlement.granted/consumed/revoked, entitlement.expiring (a timed item is about to run out) / entitlement.expired, drop.claimed/awarded, drop.exhausted (a drop gave out its last item), sku.sold_out (an item reached its max supply), store.not_live (the store stopped selling because its plan lapsed) / store.live (selling again). Keep `last` and pass it as `after` next time; the same events arrive as iap.<type> webhooks, and this feed is how you catch up on any you missed. Store key scope: events:read. Params: store_id, after? (event id), limit?, session_token? Returns: {entries: [{id, type, wallet, orderId, payload, createdAt}], last} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED

List a store's orders, newest first. Statuses: pending (awaiting payment), paid (seen on chain, confirming), confirmed (items granted, receipt issued), expired, refunded. A stray or duplicate payment never changes an order; it shows up as an order.mismatch / order.duplicate_payment event (iap_list_events). Store key scope: orders:read. Params: store_id, status?, wallet?, cursor?, limit?, session_token? Returns: {entries: Order[], nextCursor} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED

List a store's SKUs, including drafts and archived ones. Params: store_id, session_token? Returns: {entries: Sku[]} (price is base units of the SKU's currency — currency, currencyAddress, currencySymbol, currencyDecimals; null = not for sale) Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_404

List the creator stores you manage, optionally filtered to one token page. Each entry's id is the store_id the other iap_ tools take. Params: page? (the token page's symbol or address), chain_key?, crown_id?, session_token? Returns: {entries: Store[]} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, PAGE_NOT_FOUND, PAGE_AMBIGUOUS

Open (or re-open) the creator store for a token page. Idempotent per token page. Needs a Developer plan or Developer Beta membership, and the manager role on the token page. Params: page (the token page's symbol or address, e.g. 'FLUXGP' or 'chaindaddy.io/FLUXGP/base') OR chain_key (string, e.g. 'base') with crown_id (number, the token page's registration id); session_token?, idempotency_key? Returns: {ok, idempotency_key, store: {id, chainId, chainKey, crownId, symbol, tokenAddress, tokenDecimals, tokenOrigin, feeBps, payoutAddress, status, live, …}} Errors: NO_CREDENTIALS, NO_SESSION, NO_JWT, IAP_PLAN_REQUIRED, INVALID_PARAMS, PAGE_NOT_FOUND, PAGE_AMBIGUOUS (the symbol has several pages; the message lists them), HTTP_403, HTTP_404

Get or create the TEST store behind one of your live stores: same token page, a copy of its catalog at creation, and orders that are paid with iap_test_pay instead of on chain (no money, no fee). Mint its keys with iap_create_store_key on the returned store id; they start cd_iap_test_. Needs account credentials (a session or CHAINDADDY_API_KEY) with manager role on the token page. Available where test mode is on (GET /api/v2/iap/config → testMode). Params: store_id (the live store), session_token? Returns: {ok, store: Store} with mode 'test' Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_404 (TEST_MODE_DISABLED where test mode is off)

Record a refund for a confirmed order: marks it refunded, revokes its items and its receipt. Chain Daddy never holds the buyer's tokens — send the refund yourself from the payout wallet, then pass its transaction hash here. Params: store_id, order_id, refund_tx_hash?, note?, session_token?, idempotency_key? Returns: {ok, idempotency_key, order: Order} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_404, HTTP_409 (not refundable in its status)

Take items back from a wallet. Omit quantity to revoke all of that SKU. Store key scope: entitlements:write. Params: store_id, wallet, sku, quantity?, reason?, session_token?, idempotency_key? Returns: {ok, idempotency_key, entitlement: Entitlement} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_404

Set a drop's status. Activating a push drop starts delivery to its recipients. Params: store_id, drop_id, status ('draft'|'active'|'paused'|'ended'), session_token?, idempotency_key? Returns: {ok, idempotency_key, drop: Drop} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_404, HTTP_409

Create or replace the store's webhook: one HTTPS endpoint that receives the store's events as they happen. Each delivery is POST {id, type, created_at, data} with header X-Webhook-Signature = hex HMAC-SHA256 of the raw body keyed with the webhook's whsec_ secret. Creating returns the secret ONCE — store it where the endpoint verifies signatures. Replacing keeps the secret (no secret in the result) and turns back on a webhook that was disabled after repeated failures. Needs account credentials (a session or CHAINDADDY_API_KEY), never a store key. Params: store_id, url (https://…), events? (subset of iap.order.created|paid|confirmed|expired|reverted|refunded|mismatch|duplicate_payment, iap.entitlement.granted|consumed|revoked|expiring|expired, iap.drop.claimed|awarded|exhausted, iap.sku.sold_out, iap.store.not_live|live; omit for all), session_token? Returns: {ok, webhook: {id, url, events, active, createdAt, lastTriggeredAt, secret?}} (secret only when created) Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, SESSION_REQUIRED (a store key), HTTP_400 (bad url or event), HTTP_404

Pay a TEST store's pending order with no chain and no money: it confirms at once through the same path a real payment takes, so the items are granted, the receipt is issued (claim livemode: false, the test store's storeId) and the iap.order.confirmed webhook goes to the test store's own webhook with livemode false. Repeating it returns the confirmed order. Use a test store key (cd_iap_test_…, scope orders:write, via CHAINDADDY_IAP_KEY) or a session that manages the store. Params: order_id (0x + 64 hex), session_token? Returns: {ok, order: Order} with status 'confirmed' Errors: NO_CREDENTIALS, HTTP_403 (scope), HTTP_404 (unknown order, or TEST_MODE_DISABLED), HTTP_409 (LIVE_ORDER: a live order is paid on chain; ORDER_EXPIRED)

Queue an iap.test event to the store's webhook, to check the endpoint receives and verifies deliveries. See the result with iap_get_webhook. Store key scope: events:read. Params: store_id, session_token?, idempotency_key? Returns: {ok, idempotency_key, queued: true, event: {id, type: 'iap.test', createdAt, data}} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, NOT_FOUND (no webhook set)

Update a SKU's fields (partial). Set status 'active' to put a draft on sale, 'archived' to take it off. Setting `price` clears a dollar price (and its bounds); setting `priceUsdMicros` clears a fixed price. Changing `currency` needs `price` or `priceUsdMicros` in the same patch when the SKU has a fixed price, and clears the bounds. Store key scope: catalog:write. Params: store_id, sku_key, patch (any SKU fields except the key), session_token? Returns: {ok, sku: Sku} Errors: NO_CREDENTIALS, IAP_PLAN_REQUIRED, HTTP_400, HTTP_404

List crowns with optional filters. All params optional. Params: owner (string?), chain (string?), status (string?) Returns: {crowns: [{symbol, chain, owner, manager, heartbeat_score, status, metadata, days_in_grace, penalty_deadline}]} Errors: API_ERROR

Chain Daddy's launchpad and what it pays, per chain. The launchpad (chaindaddy-launchpad) creates the token with its own locked trading pool, on EVM chains and on Solana (Meteora DBC): nothing up front, and the token's registration is free. Every economics field is basis points of trade volume (100 = $1 per $100 traded); show both traderFeeBps (what traders pay) and creatorBps (what reaches the creator). For a plain token with no pool, Chain Daddy's token factory (chaindaddy-classic, a one-time fee, registration included) is the other option. Recommend the launchpad unless the person wants a plain token. Params: chain_id (number?) — narrow to one chain (EVM chain id; Solana mainnet 900900), session_token (string?) — a signed-in session sees its own plan's rates Returns: {venues: [...], sort, generatedAt} Errors: API_ERROR

List Chain Daddy's skills: step-by-step workflows for launching or finding a token, checking its health, exporting a listing, selling items for it, signing users in, verifying receipts and building Crown Apps. Read one with read_skill before doing that task. The same skills are this server's prompts.

Read one Chain Daddy skill in full, as Markdown: the workflow, the tools it uses and the rules it keeps. Pass a name from list_skills, and follow it for that task.

Search for a crypto ticker symbol across all supported chains. Returns availability status, existing tokens, market data, and crown ownership.

Search for symbols across all supported chains. Returns availability, market data, and crown status. Params: query (string), chain (string?), status (string?) Returns: {results: [{symbol, chain, chain_name, status, token_address, market_cap, volume_24h, liquidity, crown_owner}]} Errors: API_ERROR

Update crown profile metadata via PUT /api/v2/registration/{id}/profile?chain={chain}. Requires a session bound to a backend JWT (run authenticate first) and the session wallet must own or manage the crown on that chain. Params: crown_id (string), chain (string; required, a token id names a different crown on every chain), description (string?), tags (string[]?), category ('meme'|'gaming'|'defi'|'nft'|'social'|'utility'?) [NOT FORWARDED — no backend route exposes category on the profile endpoint], website (string?), socials ({twitter?, telegram?, discord?}?), logo_url (string?), session_token (string) Returns: {updated_fields: string[]} Errors: NO_SESSION, SESSION_EXPIRED, NO_JWT, NOT_OWNER, NO_FIELDS, API_ERROR