io.github.cookiechain/cookie-mcp

Accept an offer on an NFT you own, selling it to the bidder for the escrowed COOK (minus the 1% fee and royalties). Takes the highest active offer unless you pass `buyer`. Simulates before sending. Requires COOKIE_PRIVATE_KEY.

Add liquidity to a pool by opening a new position; the venue (Cookiebox DAMM v2, Cookiebox CLMM, or CookieSwap BAMM) is auto-detected from the pool. Concentrated-liquidity venues (CLMM/BAMM) open a full-range position by default. Simulates before sending. Requires COOKIE_PRIVATE_KEY.

Bridge COOK 1:1 between Cookie Chain and Solana mainnet via Hyperlane. `direction` is 'cookie-to-solana' (locks native COOK on Cookie, credits SPL COOK to the recipient's Solana account) or 'solana-to-cookie' (locks SPL COOK on Solana, credits native COOK on Cookie). `to` is the recipient on the DESTINATION chain (base58; both chains share your keypair, so it defaults to your own wallet). `amount` is a UI amount of COOK. Signs and sends one transaction on the source chain; a relayer delivers on the far side in a few minutes. Simulates first, and preflights the far side before signing: the destination's collateral must cover the release. On cookie-to-solana, if the recipient has no SPL COOK account yet, `bridge` creates it from this wallet first (one extra Solana tx, ~0.0021 SOL of account rent) — the warp route can do this itself but pays from a PDA that runs dry, and when it is dry the delivery fails inside the relayer and the transfer hangs with no error anywhere. Requires COOKIE_PRIVATE_KEY plus COOKIE_WARP_PROGRAM_ID / SOLANA_WARP_PROGRAM_ID. Returns the source tx signature and the Hyperlane message id (use bridge_status to confirm delivery); pass waitForDelivery to poll up to ~3 min inline. A wait that times out is not a failure — the transfer is still in flight; re-check with bridge_status.

Check whether a bridged COOK transfer has been delivered on the destination chain, by its Hyperlane message id (returned by `bridge`). `direction` must match the original transfer. Returns delivered true/false and the destination-chain delivery tx once relayed. No wallet needed.

Buy a .cook name that is listed for sale, paying the seller and the marketplace fee in one transaction; the name leaves escrow and belongs to this wallet, permanently. ⚠️ EXPENSIVE and FINAL: listings run into the millions of COOK. `maxPriceCook` is REQUIRED as an explicit spend confirmation — the instruction carries no price argument, so this cap is the only guard. Called without it, this quotes the live asking price and spends nothing. Use get_domain_listings to find names in budget. Simulates before sending. Requires COOKIE_PRIVATE_KEY.

Buy a listed NFT at its current listing price: funds escrow, bids, and settles the sale in one transaction; the NFT lands in your wallet. Optionally pass `maxPrice` (COOK) as a guard. Simulates before sending. Requires COOKIE_PRIVATE_KEY.

Take a .cook name this wallet listed back off the CookOven domain marketplace. The escrow returns it to this wallet and the listing rent is refunded, so transfer_domain, update_domain and set_primary_domain work on it again. Only the wallet that created the listing can cancel it. Simulates before sending. Requires COOKIE_PRIVATE_KEY.

Cancel one of your open limit / stop orders and get the remaining input back. Requires COOKIE_PRIVATE_KEY; only the maker can cancel. The refund lands in the order's pinned input account (recreated first if it was closed); a native-COOK order is refunded as COOK, a wCOOK-funded one is unwrapped in the same tx unless `unwrapSol: false`. Also how an EXPIRED order's input is recovered. The built transaction is decoded and checked (your order, refund to you, known programs only) and simulated before signing.

Cancel your active Baked Bazaar listing for an NFT and reclaim it. Requires COOKIE_PRIVATE_KEY.

Cancel your active offer on an NFT and withdraw the escrowed COOK back to your wallet. Requires COOKIE_PRIVATE_KEY.

Live Cookie Chain snapshot: slot heights per commitment, finalization lag (the key health signal — a stall causes BlockhashNotFound), epoch progress, validator/node counts, version, block-production rate, and RPC latency. No arguments.

Sweep the creator's share of trading fees (35% of the 1% trade fee) from a launchpad token you created, into your wallet as native COOK. Only the pool's creator can claim; fails early with the pending amount when nothing has accrued yet. Requires COOKIE_PRIVATE_KEY.

Claim the swap fees your liquidity position has accrued in a pool (venue auto-detected: Cookiebox DAMM v2, Cookiebox CLMM, or CookieSwap BAMM). Sweeps fees to your wallet without removing the position. Simulates before sending. Requires COOKIE_PRIVATE_KEY.

Settle a launchpad position. By default the right claim is picked from the pool's state: graduated → your real SPL tokens; expired (or `ended`) in fair mode → a pro-rata COOK refund; expired in jackpot/survivor mode → your Merkle payout (the proof is fetched for you). A fair refund works even on an `ended` pool that has not been settled on-chain yet — the claim settles it too; the other modes have to wait for the expiry transition. Creators can pass kind=creator_vest to claim their vested allocation after graduation. Dead-mode expiries have no holder payout. Simulates before sending, so a claim that cannot land costs nothing. Requires COOKIE_PRIVATE_KEY.

Create a new pool for a token pair and seed it with an initial deposit (the deposit ratio sets the starting price). `dex` selects the venue: cookiebox-damm (default), cookiebox-clmm (concentrated liquidity, full-range seed, default 0.25% fee tier), or cookieswap-bamm (concentrated liquidity; fee tier/tick spacing chosen by `ammConfig`, full-range seed). Simulates before sending; caps the COOK side. Requires COOKIE_PRIVATE_KEY.

Launch a new token on the MomoSwap launchpad (bonding curve priced in COOK, graduates to the open market at the raise target). Mint + freeze authority are renounced and the metadata is immutable, so a launch is FINAL — nothing about the token can be changed afterwards. Costs the launchpad's creation fee, read live from its config (0 on the current deployment, so a launch usually costs only account rent) plus any devBuyCook. A LOGO IS REQUIRED: pass `imagePath` (preferred for a file on this machine — the server reads and types it itself, so never base64 a local file yourself), `imageBase64` with `imageMimeType` (for an image you generated), or `imageUrl` (downloaded and re-pinned, so the logo outlives its original host). The bytes are pinned to IPFS either way. Launching without one is refused unless you set `noLogo: true`, because the metadata is immutable and a logo can never be added later. The mint address is chosen by the launchpad (the program requires one ending in `momo`). Set `devBuyCook` (or `devBuyPctOfTotalSupply` for a share of the supply) to make your own buy the atomic first trade. Requires COOKIE_PRIVATE_KEY.

Native COOK + SPL/Token-2022 token balances for a wallet, with USD values. Defaults to the configured wallet (COOKIE_PRIVATE_KEY); pass `wallet` to inspect any address or .cook name. In read-only mode (no key), `wallet` is required. Pass `chain: 'solana'` for the far side of the Hyperlane bridge instead: the wallet's SPL COOK on Solana mainnet (what a `solana-to-cookie` bridge spends) plus its SOL, which pays that transfer's fee and interchain gas. That view is COOK + SOL only — it does not enumerate other Solana tokens.

Every .cook name listed for sale on the CookOven domain marketplace, read straight from the program — no indexer, no key needed. Filter by `name` (substring match), `seller`, `maxPriceCook` or `maxLength` (short names are the scarce ones), and sort by 'price' (cheapest first), 'length' or 'recent' (default). Also returns the live marketplace fee, which the SELLER pays out of the sale price, and the floor price of the matched set. Use resolve_domain for one specific name, or register_domain for a name nobody owns yet — the market only holds names that are already registered.

Browse MomoSwap launchpad pools: name/symbol/mint, curve price in COOK, amount raised vs the graduation target (with progress %), participants, settlement mode and the launch window. Defaults to `live` launches (currently tradeable), sorted closest-to-graduation first. `ended` means the launch window closed but nobody has settled the pool on-chain yet, so it is neither tradeable nor claimable — filter for it explicitly, or use `all`, since a `live` filter may or may not include such pools depending on the launchpad's deployed version. Read-only — no key needed.

Every MomoSwap launchpad position a wallet holds, across all launches — the view get_balance CANNOT give, because pre-graduation holdings are program-tracked curve shares rather than SPL tokens. Per position: shares, COOK invested vs withdrawn, what a live curve would pay to sell now, and the `action` if something is outstanding (unclaimed tokens after graduation, an unclaimed Fair-mode refund, a settlement payout). Also lists launches this wallet created that have unclaimed creator fees or vesting. Use this to answer 'what do I hold / what can I claim'. Reads only: pass `owner` for any wallet, or omit it to use COOKIE_PRIVATE_KEY's.

Full state of one launchpad launch: curve price, raise vs graduation target, settlement mode, fee split, and — when COOKIE_PRIVATE_KEY is set — this wallet's curve position (shares, invested COOK, current sell value, what it already claimed) plus pending creator fees if it created the launch. Pass `quoteCook` to preview how many tokens a buy of that size would get. A `status` of `ended` means trading closed but the pool is not settled on-chain yet — nothing can be traded, and only a Fair-mode refund can be claimed (the claim settles the pool itself). Read-only.

Open limit / stop orders resting in the Cookiebox limit-order escrow for a wallet (yours by default, or `owner` = any address or .cook name). Read straight from the chain via the Cookiebox aggregator — no key needed. Each order shows the remaining input, the gross output the program enforces (`minReceive`), what the wallet actually receives after the maker fee (`netAfterFee`), the price (a stop's TRIGGER), fill progress, expiry and status (`open` / `filling` / `expired` — an expired order still holds its input until it is cancelled). `fees` is the live on-chain schedule in bps (null when unavailable).

Full detail for one NFT mint: metadata (name, image, attributes, collection), whether it's listed and at what price, the best current offer, and the collection floor. No wallet needed.

Active NFT listings on Baked Bazaar with prices in COOK, seller, and collection. Filter by `collection` (symbol or collection key) or `seller`, and sort by price (cheapest first) or recency. No wallet needed. Use to find NFTs to buy.

Marketplace-wide Baked Bazaar stats: active listing count, floor price, total and 24h volume, and sales counts (COOK). Optionally pass `collection` for a collection's supply and holder count. No wallet needed.

Offers a wallet has made and offers it has received (bids on NFTs it holds), with prices in COOK. Defaults to the configured wallet; pass `wallet` to inspect any address. Use before accept_offer / cancel_offer.

Every .cook name a wallet owns, plus which one is its primary (the name apps show instead of the raw address). Defaults to the configured wallet; pass `wallet` to inspect any address or .cook name. Reads the registry on-chain — no indexer, no key needed.

Liquidity pools across every Cookie Chain DEX (Cookiebox DAMM/CLMM, CookieSwap BAMM/xYBN) with TVL (USD) and 24h volume, sorted by TVL or volume. Use to find the most liquid markets.

Quote a swap across all Cookie Chain DEX liquidity via one of two aggregators: `cookiebox` (Cookiebox Swap API) or `cookiescan` (Candy Shop / Cookiescan Swap API). Quote both to compare and pick the better output. Returns expected output, output after any aggregator fee, minimum out after slippage, price impact, and the route. Quote-only — no wallet needed. `amount` is a UI amount of the input token. Pass `chain: 'solana'` to price the bridged SPL COOK (mint 36ZrtQoab5MhhySaP1YSTwUahSk6GRVUTtZ6cuVfm9e1) against SOLANA MAINNET liquidity via Jupiter. Scoped to COOK: one of inputMint/outputMint MUST be that mint — unrelated Solana pairs are refused. Needs no RPC and no wallet. On that chain So1111..112 is wSOL, NOT COOK.

Metadata + market data for a token mint: name/symbol/decimals, price (USD and COOK), 24h change, market cap, liquidity, 24h volume, holder count, and supply.

Which wallet this server acts for: the public key derived from COOKIE_PRIVATE_KEY (signer 'local'), or the wallet supplied by the request / COOKIE_WALLET_ADDRESS (signer 'external', where money tools return needs_signature instead of signing), whether it is read-only, and the Cookie Chain RPC it is pointed at. No arguments, no RPC call — so it answers even when the chain is unreachable. Use it before any money-moving tool to confirm the identity, and to tell apart the key a running server booted with from a key that has since changed on disk. Never returns the secret.

NFTs held by a wallet, each with any active Baked Bazaar listing. Defaults to the configured wallet (COOKIE_PRIVATE_KEY); pass `wallet` to inspect any address (required in read-only mode).

Buy a launchpad token on its bonding curve with COOK (the launchpad wraps the COOK and opens any missing accounts). ⚠️ You receive program-tracked CURVE SHARES, not SPL tokens: they will not show in get_balance and trade cannot swap them — exit with launchpad_sell, or claim the real token with claim_launchpad after the pool graduates. There is no slippage parameter (the program has no min-out), so the fill can move if others trade first. A 1% trade fee applies. Simulates before sending. Requires COOKIE_PRIVATE_KEY.

Sell curve shares back to a launchpad bonding curve for COOK (unwrapped to native COOK by default). Only works while the pool is live and only for shares bought via launchpad_buy — a graduated token's SPL balance is sold with `trade` instead. A 1% trade fee applies. Simulates before sending. Requires COOKIE_PRIVATE_KEY.

Put a .cook name this wallet owns up for sale on the CookOven domain marketplace at `priceCook`. ⚠️ The name moves into the marketplace ESCROW in the same instruction: until the listing is bought or cancelled, the registry reports the escrow as its owner, so this wallet cannot transfer the name, update its pointers or set it as primary, and the name no longer resolves to a payable address. cancel_domain_listing reverses it at any time. There is no re-price instruction — cancel and list again. Costs only the listing account's rent (~0.0018 COOK, refunded when the listing ends); the marketplace fee is taken from the sale price, not from you now. Simulates before sending. Requires COOKIE_PRIVATE_KEY.

List an NFT you own for sale on Baked Bazaar at `price` COOK (creates the auction-house sell order). Simulates before sending; signs locally. Requires COOKIE_PRIVATE_KEY. The 1% marketplace fee and creator royalties are taken from the sale proceeds when it sells.

⚠️ IRREVERSIBLE. Permanently locks your liquidity in a Cookiebox position; the venue is auto-detected from the pool. DAMM v2 locks the position's unlocked liquidity; CLMM locks the WHOLE position (the program offers no partial or vesting lock). Locked liquidity can never be withdrawn and the position can never be closed, but fees stay claimable via claim_fees. Not supported on CookieSwap BAMM. Requires COOKIE_PRIVATE_KEY.

Place a public offer (bid) on an NFT at `price` COOK. The COOK is escrowed with the auction house until the offer is accepted or you cancel it. Simulates before sending. Requires COOKIE_PRIVATE_KEY.

Rest an order in the Cookiebox limit-order escrow: the input is locked in a program-owned reserve and a keeper fills it through the same router `trade` uses once the executable rate reaches the price, paying the pinned output account (partial fills possible). Requires COOKIE_PRIVATE_KEY. `kind: 'limit'` (default, take-profit) fills at the price OR BETTER; the price must sit ABOVE the current rate. `kind: 'stop'` is a stop-loss, stop-MARKET: `price` is the TRIGGER, which must sit BELOW the current rate; once the rate falls to it the keeper sells at market and passes the proceeds through — a hidden on-chain floor 50% below the trigger (override with `floorPrice`) only caps what a rogue keeper could pay. Fee: the maker receives the price minus the on-chain maker fee (10 bps at launch, read live); no placement fee. Before signing, the built transaction is decoded and checked against the request (maker, amounts, kind, pinned accounts, programs) and simulated. Refuses an order that would fill or trigger immediately (use `trade` for that) unless `skipMarketCheck` is set. Native COOK input is wrapped inside the same transaction; cancel / expiry refunds it as COOK. Returns the `order` address for get_limit_orders / cancel_limit_order.

Claim an unregistered .cook name on the CookOven name service. ⚠️ EXPENSIVE and PERMANENT: the price is set in USD by the registry and paid in COOK — thousands of COOK at the current config — and registration is non-refundable with no expiry. `maxPriceCook` is REQUIRED as an explicit spend confirmation: call resolve_domain (or this tool without it) to learn the live price first, then pass that number. Refuses before signing if the name is taken or the price exceeds `maxPriceCook`. Simulates before sending. Requires COOKIE_PRIVATE_KEY.

Remove liquidity from your position in a pool (venue auto-detected). `bps` is the fraction to remove for DAMM v2 and CLMM (default 10000 = all, which also closes a CLMM position); BAMM removes the whole position. Requires COOKIE_PRIVATE_KEY.

Look up a .cook name on the CookOven name service: who owns it, when it was registered, its resolver/metadata pointers, and whether it is the owner's primary name. If the name is NOT registered, returns availability plus the live registration price (short 1–3 character names cost more than 4+ character ones). Use this before register_domain — it is free and touches no key. For the reverse direction (wallet → names) use get_owned_domains.

Resolve an NFT or collection name to a mint by searching active Baked Bazaar listings by name, symbol, or collection — partial and case-insensitive — or by mint prefix. Returns matching listed NFTs (cheapest first) with mint, collection, price in COOK, and seller. Use this FIRST whenever the user names an NFT or collection to buy but you don't have its mint, then pass the chosen mint to get_nft / buy_nft. Only currently-listed NFTs are searchable. No wallet needed.

Resolve a token name or ticker to its mint by searching the Cookiescan registry (every Cookie Chain token) by symbol/name — partial and case-insensitive — or by mint prefix. Returns ranked candidates (most liquid first) with mint, price, liquidity, 24h volume, and holders. Use this FIRST whenever the user names a token but you don't have its mint, then pass the chosen mint to get_token_info / get_quote / trade. Multiple tokens can share a symbol — compare liquidity and confirm the mint before trading. No wallet needed.

Point this wallet's primary record at one of the .cook names it owns, so apps label it by that name instead of its address. Pass `clear: true` instead of `name` to unset it (the wallet keeps the name either way). Simulates before sending. Requires COOKIE_PRIVATE_KEY.

Stake COOK into the bCOOK liquid-staking pool (SPL Stake Pool): deposits COOK and mints bCOOK to your wallet (≈ amount × 0.995 / rate, after the 0.5% deposit fee). bCOOK keeps earning as the rate rises and stays liquid/transferable. Simulates first. Requires COOKIE_PRIVATE_KEY.

Live bCOOK (liquid-staked COOK) stats: the COOK-per-bCOOK exchange rate (only ever rises), TVL, bCOOK supply, deposit/withdraw fees, and an estimated APY. Use before `stake`/`unstake`. No key needed.

Second half of an externally signed action. When the server runs with an external signer (no private key), every money-moving tool stops at the signing step and returns `{ status: 'needs_signature', transactionBase64, submit, blockhash, lastValidBlockHeight, what, step }`. Sign `transactionBase64` with the user's wallet WITHOUT modifying it (it is already verified, simulated and co-signed), then call this with the signed bytes and the same `submit`, `blockhash`, `lastValidBlockHeight` and `what` fields. It sends on the named route, confirms, and returns the signature. If the original result said `step: 'intermediate'`, call the original tool again afterwards to continue. Refuses bytes that still lack a signature. Never builds or alters transactions.

Execute a swap via the chosen aggregator (`cookiebox` by default, or `cookiescan` = Candy Shop): the aggregator quotes and builds the tx; we simulate, sign locally with the configured wallet, submit, and confirm. Non-custodial. Requires COOKIE_PRIVATE_KEY. Use get_quote first to compare aggregators. `amount` is a UI amount of the input token. Returns the tx signature + explorer link. Pass `chain: 'solana'` to buy or sell the bridged SPL COOK on SOLANA MAINNET via Jupiter, paying fees in SOL. Scoped to COOK: one of inputMint/outputMint MUST be 36ZrtQoab5MhhySaP1YSTwUahSk6GRVUTtZ6cuVfm9e1 — unrelated Solana pairs are refused. The SAME COOKIE_PRIVATE_KEY signs on both chains, and that path requires SOLANA_RPC_URL to point at a dedicated RPC (the public endpoint is refused). On Solana So1111..112 is wSOL, NOT COOK. COOK and wCOOK (wrapped, SPL) share the native mint: pass `wrapSol: false` to pay from a wCOOK balance, `unwrapSol: false` to receive wCOOK (cookiebox aggregator only).

Send native COOK (omit `mint` or use the COOK mint) or an SPL/Token-2022 token to another wallet, creating the recipient's token account if needed. An optional `memo` is written to the transaction through the SPL Memo program, signed by this wallet — pass it when paying an invoice or payment request whose app matches transfers by memo. Simulates before sending. Requires COOKIE_PRIVATE_KEY.