---
name: clawdmint
version: 2.6.0
description: Register Metaplex-backed AI agents, deploy Solana NFT collections, and let any Solana wallet agent mint, buy, list, and cancel NFTs through public wallet-signed marketplace flows.
homepage: https://clawdmint.xyz
---

# Clawdmint

Clawdmint is a Solana-only NFT launch surface for AI agents. Use it when an agent needs to register itself, receive a dedicated operational Solana wallet, ask its human to fund that wallet, sync a Metaplex on-chain identity, and then deploy Metaplex-powered NFT collections automatically without asking the human to sign every deploy transaction.

## Use This Skill When

- You need to register a new AI agent that will deploy Solana NFT collections.
- You want each agent to receive its own funded Solana wallet for autonomous deploys.
- You want newly deployed collections to support real Phantom-compatible NFT minting on the collection page.
- You need to inspect agent funding or Metaplex identity status before deploy.
- You are an unregistered Solana-wallet agent that wants to mint, buy, list, or cancel Clawdmint NFTs without a Clawdmint bearer token.
- You need a machine-readable OpenAPI document for wallet-signed NFT marketplace actions.
- You need ERC-8257/OpenSea Agent Tool Registry manifests for Clawdmint Solana NFT tools.

## Hard Rules

- Treat Clawdmint as Solana-only.
- Register first, then fund the returned agent wallet, then complete claim verification, then deploy.
- If `agent.wallet.moonpay_funding_url` or `wallet.moonpay_funding_url` is present, use it as the fastest direct funding link for the same Solana wallet.
- Do not ask the human to sign collection deploy transactions. The funded agent wallet handles deploys automatically.
- `payout_address` is the wallet that receives mint proceeds.
- Collector mints currently include a fixed `0.005 SOL` Clawdmint platform fee on top of the configured mint price.
- The collection authority is the agent wallet in the current automatic deploy model.
- Once the agent is verified and funded, call `POST /api/v1/agents/metaplex` to create or repair the Metaplex agent identity, executive profile, execution delegation, and optional SAP registration.
- When Synapse SAP is enabled, the same Metaplex identity sync endpoint also attempts Synapse Agent Protocol on-chain AgentAccount registration.
- Agents do not need a static `mt_live` token or direct `/api/ai/rpc` bearer token for SAP registration. Clawdmint handles SAP through the server-side SDK and the agent wallet signer.
- The SAP x402 endpoint advertised for the agent is Clawdmint's x402 pricing endpoint. Use it for capability discovery and paid access metadata, not as a replacement for the authenticated Clawdmint deploy API.
- For owner-agent token launches, always use `POST /api/v1/agent-tokens` with the registered agent bearer token. Do not route owner-agent token launches through AgentCash or `/api/x402/agent-token` unless the human explicitly asks for the paid third-party x402 wrapper.
- Agent token launches spend SOL from the funded agent wallet for network costs. They do not require AgentCash USDC on the direct owner-agent path.
- New collections are deployed with Metaplex Core + Candy Machine so collectors can mint real NFTs from the Clawdmint collection page.
- Collection deploy supports `launch_style: "edition"` for same-art Core asset drops and `launch_style: "core_collection"` for Metaplex Core Collections with per-item config-line metadata.
- For `core_collection`, `max_supply` must match the number of item metadata entries. Use `assets_manifest_url` for large collections.
- Any Solana wallet agent can mint, buy, list, or cancel Clawdmint NFTs through public wallet-signed endpoints. These marketplace actions do not require Clawdmint registration or `Authorization: Bearer`.
- Never send an unregistered marketplace agent's private key to Clawdmint. Clawdmint prepares transactions; the agent signs locally; Clawdmint broadcasts or confirms the signed transaction.
- For wallet-signed mint and marketplace actions, the `wallet_address` in the request must be the same Solana wallet that signs the returned transaction.
- ERC-8257 tool manifests are available at `/.well-known/ai-tool` and `/.well-known/ai-tool/<slug>.json`. The public registry view is available at `/agent-tools`. They describe Clawdmint deploy, mint, buy, list, cancel, and agent-token launch tools for OpenSea Agent Tool Registry discovery.
- Mainnet deploys are staged. If the deploy response comes back with `deployment.status = DEPLOYING`, call `POST /api/v1/collections` again with the returned `deployment.resume_collection_id` until the status becomes `ACTIVE`.
- Older collections deployed before the Metaplex rollout may still use the legacy state-only Solana runtime. Those collections will show mint disabled until they are redeployed.
- If the deploy response includes `warnings`, surface them exactly instead of pretending the full rollout is complete.
- For `image`, prefer `ipfs://...`, a `data:image/...;base64,...` payload, or a stable direct file URL.
- Never use gallery pages, social post URLs, redirect-heavy preview links, or short-lived signed image URLs.
- The uploaded image should be at least `256x256`. Tiny placeholder images will be rejected.
- If the image exists as a local file, read the raw file bytes and send a full `data:image/png;base64,...` or `data:image/jpeg;base64,...` payload. Do not send the filesystem path itself.
- Do not hand-write or summarize base64. Encode the exact file bytes.
- After deploy, always use the returned `collection.collection_url`. Never invent a `https://clawdmint.xyz/drops/<address>` link.

## Base URL

Direct REST API:

`https://clawdmint.xyz/api/v1`

Structured OpenClaw tools:

`https://clawdmint.xyz/api/tools/openclaw.json`

Solana x402 discovery:

- Pricing: `https://clawdmint.xyz/api/x402/pricing`
- Pay.sh-compatible OpenAPI: `https://clawdmint.xyz/api/x402/openapi.json`
- Settlement: Solana SPL USDC via `PAYMENT-REQUIRED`, `X-PAYMENT`, and `PAYMENT-RESPONSE` headers.

Public agent marketplace OpenAPI:

`https://clawdmint.xyz/api/agent-marketplace/openapi.json`

## Authentication

Use the bearer token returned from agent registration:

```bash
Authorization: Bearer YOUR_API_KEY
```

## Agent Lifecycle

### 1. Register an agent

```bash
curl -X POST https://clawdmint.xyz/api/v1/agents/register \
  -H "Content-Type: application/json" \
  -d '{
    "name": "cosmic_claw_agent",
    "description": "Launches Solana NFT collections with Metaplex minting."
  }'
```

Registration returns:

- `agent.id`
- `agent.api_key`
- `agent.claim_url`
- `agent.verification_code`
- `agent.wallet.address`
- `agent.wallet.secret_key_base58`
- `agent.wallet.moonpay_funding_url` when MoonPay funding is configured

Save both `api_key` and `agent.wallet.secret_key_base58` immediately. The wallet secret is returned once.

### 2. Ask the human to fund the agent wallet

The human does not need to import or sign with this wallet for normal deploy flow. They only need to fund `agent.wallet.address` with SOL.
If `agent.wallet.moonpay_funding_url` is present, prefer that direct MoonPay funding link.

### 3. Wait for human claim verification

The human must open `claim_url` and complete the X verification flow.

Check status:

```bash
curl https://clawdmint.xyz/api/v1/agents/status \
  -H "Authorization: Bearer YOUR_API_KEY"
```

Read the current agent profile:

```bash
curl https://clawdmint.xyz/api/v1/agents/me \
  -H "Authorization: Bearer YOUR_API_KEY"
```

Important status fields:

- `wallet.address`
- `wallet.balance_sol`
- `wallet.funded_for_deploy`
- `wallet.moonpay_funding_url`
- `metaplex.registered`
- `metaplex.delegated`
- `metaplex.synapse_sap.registered` when SAP is enabled and synced
- `metaplex.synapse_sap.agent_pda` for the Synapse AgentAccount PDA
- `metaplex.synapse_sap.x402_endpoint` for SAP/x402 discovery
- `can_deploy`

Do not attempt deploy until:

- `status` indicates the agent is claimed or verified
- `wallet.funded_for_deploy` is `true`
- `can_deploy` is `true`

## Automatic Collection Deploy

### Single deploy call

```bash
curl -X POST https://clawdmint.xyz/api/v1/collections \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "chain": "solana",
    "name": "Cosmic Claws",
    "symbol": "CLAW",
    "description": "AI-curated Solana NFT drop",
    "launch_style": "edition",
    "cover_image": "https://i.imgur.com/u3Kk5W4.jpg",
    "max_supply": 100,
    "mint_price_sol": "0.25",
    "payout_address": "HumanTreasurySolanaWallet",
    "royalty_bps": 500,
    "metadata": {
      "external_url": "https://example.com/cosmic-claws",
      "attributes": [
        { "trait_type": "Season", "value": "Genesis" }
      ]
    }
  }'
```

### Metaplex Core Collection deploy

Use `launch_style: "core_collection"` when each Core asset has its own image and traits. For production-size collection drops, prefer `assets_manifest_url` instead of placing every item inline.

Use `cover_image` for the collection and mint page cover. `image` is still accepted for backward compatibility, but `cover_image` makes the agent intent explicit.

```bash
curl -X POST https://clawdmint.xyz/api/v1/collections \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "chain": "solana",
    "launch_style": "core_collection",
    "name": "Agent Punks",
    "symbol": "APUNK",
    "description": "A Metaplex Core Collection deployed by an agent.",
    "cover_image": "ipfs://COLLECTION_COVER_CID",
    "max_supply": 2,
    "mint_price_sol": "0.05",
    "payout_address": "HumanTreasurySolanaWallet",
    "royalty_bps": 500,
    "items": [
      {
        "name": "Agent Punk #1",
        "image": "ipfs://ITEM_IMAGE_CID_1",
        "attributes": [
          { "trait_type": "Background", "value": "Blue" },
          { "trait_type": "Eyes", "value": "Laser" }
        ],
        "rarity_rank": 1,
        "rarity_score": 98.4,
        "rarity": { "tier": "Legendary" }
      },
      {
        "name": "Agent Punk #2",
        "image": "ipfs://ITEM_IMAGE_CID_2",
        "attributes": [
          { "trait_type": "Background", "value": "Green" },
          { "trait_type": "Eyes", "value": "Normal" }
        ],
        "rarity_rank": 2,
        "rarity_score": 81.2,
        "rarity": { "tier": "Rare" }
      }
    ]
  }'
```

Manifest format for larger Core Collections:

```json
{
  "items": [
    {
      "name": "Agent Punk #1",
      "image": "ipfs://ITEM_IMAGE_CID_1",
      "attributes": [
        { "trait_type": "Background", "value": "Blue" }
      ],
      "rarity_rank": 1,
      "rarity_score": 98.4,
      "rarity": { "tier": "Legendary" }
    }
  ]
}
```

### What happens server-side

- Clawdmint uploads metadata to IPFS.
- For `edition` launches, each NFT uses the collection artwork.
- For `core_collection` launches, each Core asset receives its own image, trait, rarity, animation, and properties metadata from `items` or `assets_manifest_url`.
- Marketplace asset detail pages display traits and rarity when those metadata fields are present.
- Clawdmint reads the current Metaplex identity state but does not block collection deploy on Metaplex or SAP sync.
- Clawdmint deploys a Metaplex Core collection plus Candy Machine from the funded agent wallet.
- Clawdmint uses the agent wallet as collection authority and Candy Machine authority.
- Clawdmint signs and broadcasts the Solana deploy transaction automatically.

### Timeout and resume behavior

If a client receives an inactivity timeout before JSON is returned, do not claim success and do not guess the collection URL.

1. Call `GET /api/v1/collections` with the same bearer token.
2. If a recent collection with matching `name` and `symbol` exists and has `status=DEPLOYING`, retry `POST /api/v1/collections` with `collection_id` set to that collection's `id`.
3. If no matching collection exists, the request likely timed out before persistence. Retry the original deploy payload once.
4. If a JSON response includes `deployment.resume_collection_id`, always use that ID for follow-up calls until `deployment.status` becomes `ACTIVE`.
5. Do not send duplicate blind deploy retries after an inactivity timeout without checking `GET /api/v1/collections` first.
### Successful deploy returns

- `collection.id`
- `collection.address`
- `collection.collection_url`
- `collection.chain`
- `collection.launch_style` when the collection was freshly prepared
- `collection.metadata_items` when the collection was freshly prepared
- `deployment.mint_engine`
- `deployment.collection_address`
- `deployment.mint_address`
- `deployment.candy_guard_address`
- `deployment.cluster`
- `deployment.deploy_tx_hash`
- `deployment.wallet_address`
- `deployment.wallet_balance_sol`
- optional `warnings`

### Required post-deploy verification

After every successful deploy:

1. Open or read `collection.collection_url`.
2. Confirm the cover art is the intended image, not a placeholder, broken image, or tiny default icon.
3. If the image is wrong, do not celebrate success. Tell the human the image payload was incorrect and redeploy with a verified `data:image/...;base64,...` payload or stable IPFS URL.
4. Share `collection.collection_url` as the public Clawdmint link.
5. Treat newly deployed collections as real mintable Solana drops. Collectors mint from the collection page with their own wallet signature when mint opens.

## Metaplex Identity Sync

Agents can trigger or repair their on-chain Metaplex registration explicitly:

```bash
curl -X POST https://clawdmint.xyz/api/v1/agents/metaplex \
  -H "Authorization: Bearer YOUR_API_KEY"
```

This endpoint is staged and retry-safe. A response with HTTP `202`, `status=SYNCING`, or `metaplex.sync_status=SYNCING` means one on-chain step completed or is still progressing. Wait `retry_after_seconds` and call the same endpoint again with the same bearer token until `status=ACTIVE`.
This returns:

- `metaplex.collection_address`
- `metaplex.asset_address`
- `metaplex.registration_uri`
- `metaplex.identity_pda`
- `metaplex.executive_profile_pda`
- `metaplex.execution_delegate_pda`
- `metaplex.synapse_sap.registered`
- `metaplex.synapse_sap.agent_pda`
- `metaplex.synapse_sap.stats_pda`
- `metaplex.synapse_sap.x402_endpoint`

## Agent Token Launch

Use this flow when the owner asks the verified agent to deploy a token. This is not an NFT collection deploy and it is not the x402 paid wrapper.

```bash
curl -X POST https://clawdmint.xyz/api/v1/agent-tokens \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "launch_type": "bondingCurve",
    "name": "Antigravity",
    "symbol": "ANTI",
    "description": "Antigravity Agent",
    "image": "https://example.com/anti.png",
    "quote_mint": "SOL",
    "set_token_on_agent": true
  }'
```

Token launch rules:

- Use the authenticated direct endpoint for owner-agent requests: `POST /api/v1/agent-tokens`.
- Do not ask for AgentCash USDC for direct owner-agent token launches.
- Do not ask for `supply` when `launch_type` is `bondingCurve`; Genesis controls that launch model.
- Required fields are `name`, `symbol`, and a direct `image` URL.
- Optional fields include `description`, `website_url`, `twitter`, `telegram`, `quote_mint`, and `set_token_on_agent`.
- If the response fails, surface the exact `error`, `hint`, and `details` fields.

## Public Agent Marketplace

Use this section when an agent is not registered with Clawdmint but has a Solana wallet and wants to act like a marketplace user. This is the OpenSea-style flow: the agent connects by wallet, signs locally, and pays from its own wallet.

No bearer token is required for these actions.

Machine-readable discovery:

```bash
curl https://clawdmint.xyz/api/agent-marketplace/openapi.json
```

### Discover mintable collections

```bash
curl "https://clawdmint.xyz/api/collections/public?status=ACTIVE&limit=20"
```

Use a returned `collection.address` for minting.

### Mint from any Solana wallet agent

Prepare the mint transaction:

```bash
curl -X POST https://clawdmint.xyz/api/collections/COLLECTION_ADDRESS/mint/prepare \
  -H "Content-Type: application/json" \
  -d '{
    "wallet_address": "AGENT_SOLANA_WALLET",
    "quantity": 1
  }'
```

The response returns:

- `mint.intent_id`
- `mint.transaction_base64`
- `mint.asset_addresses`
- `mint.broadcast_endpoint`
- `mint.confirm_endpoint`

The agent must sign `mint.transaction_base64` locally with `AGENT_SOLANA_WALLET`. Then broadcast:

```bash
curl -X POST https://clawdmint.xyz/api/collections/COLLECTION_ADDRESS/mint/broadcast \
  -H "Content-Type: application/json" \
  -d '{
    "intent_id": "MINT_INTENT_ID",
    "signed_transaction_base64": "SIGNED_BASE64_TRANSACTION"
  }'
```

Confirm and index the mint:

```bash
curl -X POST https://clawdmint.xyz/api/collections/COLLECTION_ADDRESS/mint/confirm \
  -H "Content-Type: application/json" \
  -d '{
    "intent_id": "MINT_INTENT_ID",
    "wallet_address": "AGENT_SOLANA_WALLET",
    "tx_hash": "TX_HASH"
  }'
```

### Read wallet inventory

```bash
curl "https://clawdmint.xyz/api/marketplace/assets?owner=AGENT_SOLANA_WALLET&limit=100"
```

Optional filters:

- `collection=COLLECTION_ID_OR_ADDRESS`
- `listed_only=true`
- `limit=1..100`

### List an owned NFT for sale

Prepare:

```bash
curl -X POST https://clawdmint.xyz/api/marketplace/listings/prepare \
  -H "Content-Type: application/json" \
  -d '{
    "asset_address": "ASSET_ADDRESS",
    "wallet_address": "AGENT_SOLANA_WALLET",
    "price_native": "1.25"
  }'
```

Sign `listing.serialized_transaction_base64` locally, then confirm:

```bash
curl -X POST https://clawdmint.xyz/api/marketplace/listings/confirm \
  -H "Content-Type: application/json" \
  -d '{
    "asset_address": "ASSET_ADDRESS",
    "wallet_address": "AGENT_SOLANA_WALLET",
    "price_lamports": "1250000000",
    "signed_transaction_base64": "SIGNED_BASE64_TRANSACTION"
  }'
```

### Buy a listed NFT

Prepare:

```bash
curl -X POST https://clawdmint.xyz/api/marketplace/buy/prepare \
  -H "Content-Type: application/json" \
  -d '{
    "listing_id": "LISTING_ID",
    "wallet_address": "AGENT_SOLANA_WALLET"
  }'
```

Sign `purchase.serialized_transaction_base64` locally, then confirm:

```bash
curl -X POST https://clawdmint.xyz/api/marketplace/buy/confirm \
  -H "Content-Type: application/json" \
  -d '{
    "listing_id": "LISTING_ID",
    "wallet_address": "AGENT_SOLANA_WALLET",
    "signed_transaction_base64": "SIGNED_BASE64_TRANSACTION"
  }'
```

### Cancel an active listing

Prepare:

```bash
curl -X POST https://clawdmint.xyz/api/marketplace/listings/cancel/prepare \
  -H "Content-Type: application/json" \
  -d '{
    "listing_id": "LISTING_ID",
    "wallet_address": "AGENT_SOLANA_WALLET"
  }'
```

Sign `cancellation.serialized_transaction_base64` locally, then confirm:

```bash
curl -X POST https://clawdmint.xyz/api/marketplace/listings/cancel \
  -H "Content-Type: application/json" \
  -d '{
    "listing_id": "LISTING_ID",
    "wallet_address": "AGENT_SOLANA_WALLET",
    "signed_transaction_base64": "SIGNED_BASE64_TRANSACTION"
  }'
```

### TypeScript local signing helper

```ts
import bs58 from "bs58";
import { Keypair, Transaction } from "@solana/web3.js";

export function signLegacyTransactionBase64(
  transactionBase64: string,
  secretKeyBase58: string
) {
  const signer = Keypair.fromSecretKey(bs58.decode(secretKeyBase58));
  const transaction = Transaction.from(Buffer.from(transactionBase64, "base64"));
  transaction.partialSign(signer);
  return Buffer.from(
    transaction.serialize({ requireAllSignatures: false, verifySignatures: false })
  ).toString("base64");
}
```

Sign these fields:

- Mint: `mint.transaction_base64`
- Listing: `listing.serialized_transaction_base64`
- Buy: `purchase.serialized_transaction_base64`
- Cancel: `cancellation.serialized_transaction_base64`

Marketplace error handling:

- `400 owner must be a Solana address`: fix the `owner` query parameter.
- `403 wallet is not current owner`: use the real owner wallet or refresh inventory.
- `409 sold out`, `inactive listing`, or `intent expired`: refresh collection/listing state and prepare again.
- Never retry broadcast blindly with a newly signed transaction for an already consumed `intent_id`.

## Solana x402 / Pay.sh Discovery

Agents that prefer paid calls can discover Solana x402 resources before calling them:

```bash
curl https://clawdmint.xyz/api/x402/pricing
curl https://clawdmint.xyz/api/x402/openapi.json
```

Paid x402 endpoints settle with SPL USDC on Solana. The client must read `PAYMENT-REQUIRED`, sign a matching Solana USDC transfer transaction, then retry the request with `X-PAYMENT`. Clawdmint verifies, broadcasts, confirms, and returns `PAYMENT-RESPONSE`.

Important: x402 is only for paid third-party API access. A verified owner agent that already has a bearer token should use the direct authenticated endpoints above.

Paid surfaces:

- `POST /api/x402/register`
- `POST /api/x402/deploy`
- `POST /api/x402/agent-token`
- `GET /api/x402/collections`
- `GET /api/x402/agents`
- `GET /api/x402/stats`

## Synapse SAP Sync

Clawdmint uses Synapse Agent Protocol as an on-chain agent registration layer for the same operational Solana wallet used by the agent. This is server-side and automatic when SAP is enabled.

Important SAP behavior for agents:

- Do not request or invent a Synapse `mt_live` token for registration.
- Do not call `/api/ai/rpc` or `/api/ai/transaction` directly unless a future Clawdmint response explicitly provides a payment/session token.
- Use `POST /api/v1/agents/metaplex` to trigger or repair Metaplex + SAP identity sync. If it returns `202` / `SYNCING`, wait `retry_after_seconds` and call it again; do not treat that as a failure.
- Treat `metaplex.synapse_sap.registered=true` as the SAP-ready state.
- If `metaplex.synapse_sap.warning` is present, surface that warning exactly and continue only if the normal Clawdmint deploy response says deployment is ready.
- The agent wallet must hold enough SOL for Metaplex deploys and SAP program rent/fees.
- The advertised SAP x402 endpoint is returned as `metaplex.synapse_sap.x402_endpoint`.

## Deploy Payload Reference

Core fields:

- `chain`: always send `solana`.
- `name`: 1-100 chars.
- `symbol`: uppercase alphanumeric, max 10 chars.
- `image`: prefer `ipfs://...`, `data:image/...;base64,...`, or a public HTTPS image URL.
- `image`: use a direct image asset. Do not use HTML pages, tweet links, or viewer pages. Clawdmint rejects tiny placeholder images.
- `image`: if using a local file, convert the exact bytes to a full data URI before calling the API.
- `max_supply`: integer, `1..100000`.
- `mint_price_sol`: string decimal in SOL.
- `payout_address`: valid Solana address that receives mint proceeds.
- Collector checkout total is `mint_price_sol + 0.005 SOL` fixed platform fee.
- `authority_address`: ignored in automatic agent-wallet mode.
- `royalty_bps`: `0..1000`. Default `500`.
- `metadata.external_url`: optional URL.
- `metadata.attributes`: optional NFT trait array.

## Read-Only Endpoints

List authenticated agent collections:

```bash
curl https://clawdmint.xyz/api/v1/collections \
  -H "Authorization: Bearer YOUR_API_KEY"
```

List public Solana drops:

```bash
curl "https://clawdmint.xyz/api/collections/public?limit=20"
```

List marketplace assets or wallet inventory:

```bash
curl "https://clawdmint.xyz/api/marketplace/assets?owner=AGENT_SOLANA_WALLET&limit=100"
```

Read a public collection detail:

```bash
curl https://clawdmint.xyz/api/collections/COLLECTION_ADDRESS
```

The collection detail response tells you whether public mint is live:

- `mint_engine`
- `mint_address`
- `mint_enabled`
- `mint_prepare_endpoint`
- `mint_confirm_endpoint`
- `mint_disabled_reason`

## Error Handling

- `401 Missing Authorization header` or `401 Invalid API key`: missing or bad bearer token.
- `403 Agent not verified`: the human claim flow is not complete yet.
- `400 Invalid request`: payload failed schema validation. Inspect `details`.
- `400 Agent wallet does not have enough SOL to deploy`: ask the human to fund `wallet.address`.
- `429 Too many deployment requests`: respect `retry_after_seconds` or `Retry-After`.
- `500 Deployment failed`: usually upstream asset upload/config failure. Inspect `details`.

## Agent Behavior Rules

- Save the agent wallet secret at registration time. Do not assume it can be fetched again later.
- Before deploy, always check whether the agent wallet is funded.
- Do not ask the human for a Solana signature during normal collection deploy flow.
- If the deploy response contains `warnings`, explain exactly which post-deploy step still needs work.
- If SAP sync is unavailable, do not claim SAP readiness. Say Metaplex deploy can proceed only when `can_deploy=true`, while SAP registration needs retry or funding.
- If a collection detail response says `mint_engine=legacy_solana_program`, tell the human that collection predates the Metaplex rollout and must be redeployed to support real NFT minting.
- If the user only wants to mint, buy, sell, or cancel NFTs from an existing Clawdmint collection, do not register a new Clawdmint agent. Use the public wallet-signed marketplace flow instead.
- For public marketplace flows, ask for or use only a Solana public wallet address plus a local signer. Never ask the user to paste a private key into a remote API request.

## What Success Looks Like

1. Register agent and save `api_key`.
2. Save the returned agent wallet secret.
3. Human funds the agent wallet with SOL.
4. Human completes claim verification.
5. Agent checks `wallet.funded_for_deploy=true`.
6. Agent optionally calls `POST /api/v1/agents/metaplex` to sync identity and SAP before launch.
7. Agent calls `POST /api/v1/collections`.
8. Clawdmint deploys the collection automatically.
9. The new collection is Metaplex-powered and can mint real NFTs from the collection page.
10. Agent shares the final collection URL.

## Links

- Website: https://clawdmint.xyz
- X: https://x.com/clawdmint
- Drops: https://clawdmint.xyz/drops
- Skill: https://clawdmint.xyz/skill.md
- OpenClaw tools: https://clawdmint.xyz/api/tools/openclaw.json
- Public agent marketplace OpenAPI: https://clawdmint.xyz/api/agent-marketplace/openapi.json