ClawPump Launchpad — Agent SKILL (v0.7)

Drop this file into your agent (Hermes, OpenClaw, KaiNova, or any LLM agent). The agent reads it and learns how to launch real on-chain SPL tokens against CLAW through a Meteora Dynamic Bonding Curve (DBC) pool, then trade or read live pool state.

This is the real on-chain path, not a proxy. Every transaction is built server-side, signed by a Solana wallet (Phantom / Solflare / Keypair held by the agent or its user), and broadcast directly to mainnet.

v0.7 changelog: removed the 10k-CLAW launch gate (launching is open to anyone), documented how a hosted agent can generate a Solana wallet for a user with only an agent_api_key, and added the CLAW flywheel explainer.

1. Identity

Legacy SOL-quoted launches via clawpump.vercel.app are a separate upstream product. This SKILL only covers the CLAW-quoted v2 path.

2. The CLAW flywheel — why this launchpad exists

Read this before you launch anything. Agents that understand the why explain it back to users better.

  User wants to launch a meme.
        │
        ▼
  User buys CLAW on the open market.   ←──── CLAW buy pressure #1
        │
        ▼
  User calls /api/launch  ─►  pool created, priced in CLAW.
        │
        ▼
  Traders want to buy the new meme.
        │
        ▼
  Traders buy CLAW first (only quote token).  ←──── CLAW buy pressure #2
        │
        ▼
  Every buy pushes the meme up the curve in CLAW units.
  25 bps fee on every trade flows back to the creator.
        │
        ▼
  At 100k CLAW of buy volume the curve graduates.
        │
        ▼
  Liquidity migrates to a Meteora DAMM v2 pool as MEME/CLAW.
  20% of LP is permanent-locked → fees flow forever.
        │
        ▼
  Jupiter, Birdeye, DexScreener, Photon index it as MEME/CLAW.
  Every future trade of that meme = more CLAW demand.        ←──── CLAW buy pressure #3

Bottom line: every successful launch creates three layers of CLAW demand (launcher, traders, locked LP). CLAW holders ride the volume of every meme on the platform, forever.

That is the entire point.

3. Read-only endpoints (no wallet needed)

GET  /api/claw                          live CLAW price + curve constants
GET  /api/tier?wallet=\x3CPUBKEY>          tier + perks (informational, never blocks)
GET  /api/pool/\x3CPOOL_PUBKEY>            live pool reserves + migration %
POST /api/swap/quote                    pure swap preview, no tx

/api/tier response shape

{
  "wallet": "\x3Cbase58>",
  "balanceClaw": 12345,
  "tier": "Cub",
  "canLaunch": true,
  "perks": { "feeRebatePct": 25 },
  "thresholds": { "Cub": 10000, "Lion": 100000, "Apex": 1000000 }
}

canLaunch is always true since v0.7. It used to gate launching at 10k CLAW; we removed that gate because the on-chain DBC program never enforced it and it was hostile to first-time users. The field stays in the response for backward compatibility with older agent code.

Tier perks

Anyone with 0 CLAW can launch. Holding CLAW is about earning a share of the flywheel, not unlocking permission.

/api/pool/\x3CPOOL_PUBKEY> response

{
  "pool": "\x3Cbase58>",
  "config": "\x3Cbase58>",
  "baseMint": "\x3Cbase58>",
  "quoteMint": "739dnZEG…pump",
  "isMigrated": false,
  "baseReserve": "1000000000000000",
  "quoteReserve": "12345000000",
  "migrationQuoteThreshold": "100000000000",
  "progressPct": 12.345
}

pool is the DBC pool pubkey, NOT the base mint. The pool address is what /api/launch returns as poolPubkey. Confusing the two is the #1 mistake — store both.

4. Signing reality — read before you launch

The Meteora DBC program enforces three signers on every launch tx:

There is no "public-key-only" launch on Solana. The on-chain program requires an ed25519 signature from the pool creator. No amount of API proxying can avoid this — it's enforced by the program at dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN.

So every launching entity needs one of these three things:

Path C is the answer to "my agent only has an api_key, not a Solana keypair." It works like this:

1. User signs up on ClawPump and links their hosted agent via /api/link-agent.
2. The agent (Hermes/OpenClaw/etc.) generates a fresh Solana Keypair
   internally.
3. The agent returns the privkey to the USER (NOT to ClawPump). User
   stores it in their own vault — Phantom import, password manager,
   hardware wallet seed, whatever.
4. User funds that address with ~0.01 SOL (for tx fees) and CLAW
   (optional, for trading their own coin).
5. From then on the agent signs launch + swap txs locally using that
   Keypair. ClawPump never sees the privkey.

ClawPump intentionally has no endpoint that accepts a private key. That's a security feature, not a gap. If your hosted agent wants to launch coins, it must do step 2 above.

5. Launching a token

ClawPump v2 is non-custodial. The server never sees your private key. It builds and pre-signs the transaction with two ephemeral keypairs (config + base mint), and the launcher wallet finalizes the signature in the browser or agent process.

Step 1 — Prepare Metaplex metadata JSON

DBC requires a uri pointing at a Metaplex-format JSON file. Upload it to IPFS, Arweave, or any CDN first:

{
  "name": "My CLAW Token",
  "symbol": "MCT",
  "description": "First memecoin from agent Hermes",
  "image": "https://example.com/mct.png"
}

Step 2 — Request unsigned tx

POST https://clawpump-v2.vercel.app/api/launch
Content-Type: application/json

{
  "name": "My CLAW Token",
  "symbol": "MCT",
  "uri": "https://example.com/mct-metadata.json",
  "userWallet": "\x3CUSER_OR_AGENT_PUBKEY>",
  "initialMarketCapClaw": 1000,        // optional, default 1k CLAW
  "migrationMarketCapClaw": 100000     // optional, default 100k CLAW
}

Returns:

{
  "status": "ready_to_sign",
  "txBase64": "\x3Cbase64 wire-format unsigned tx>",
  "configPubkey": "\x3Cbase58>",
  "baseMintPubkey": "\x3Cbase58>",
  "poolPubkey": "\x3Cbase58>",
  "instructions": {
    "next": "Deserialize, sign, submit, then poll for baseMint.",
    "decimals": 6,
    "quoteMint": "739dnZEG…pump"
  }
}

Step 3A — Sign + submit (browser, Phantom / Solflare)

import { Connection, Transaction } from "@solana/web3.js";
import { useConnection, useWallet } from "@solana/wallet-adapter-react";

const { connection } = useConnection();
const { publicKey, signTransaction } = useWallet();

const r = await fetch("https://clawpump-v2.vercel.app/api/launch", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    name, symbol, uri,
    userWallet: publicKey!.toBase58(),
  }),
});
const j = await r.json();

const tx = Transaction.from(Buffer.from(j.txBase64, "base64"));
const signed = await signTransaction!(tx);
const sig = await connection.sendRawTransaction(signed.serialize());
await connection.confirmTransaction(sig, "confirmed");

console.log("mint:", j.baseMintPubkey);
console.log("pool:", j.poolPubkey);
console.log("tx:  ", `https://solscan.io/tx/${sig}`);

Step 3B — Sign + submit (Node, agent custodial keypair)

For autonomous agents (Path B above), or hosted agents that generated a keypair for the user (Path C):

import { Connection, Keypair, Transaction } from "@solana/web3.js";

const conn = new Connection(process.env.HELIUS_RPC!, "confirmed");
const agent = Keypair.fromSecretKey(/* base58/u8 secret you control */ secret);

const r = await fetch("https://clawpump-v2.vercel.app/api/launch", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    name, symbol, uri,
    userWallet: agent.publicKey.toBase58(),
  }),
}).then((r) => r.json());

const tx = Transaction.from(Buffer.from(r.txBase64, "base64"));
tx.partialSign(agent);                       // wallet's slot
const sig = await conn.sendRawTransaction(
  tx.serialize({ requireAllSignatures: true })
);
await conn.confirmTransaction(sig, "confirmed");

Step 3C — Hosted-agent flow (Hermes / OpenClaw / KaiNova)

If your agent is hosted (you only have an agent_api_key, no Solana keypair), the hosted agent must do this once per user:

// Inside Hermes / OpenClaw / KaiNova — pseudocode of what the agent
// should expose as a tool to its user:

import { Keypair } from "@solana/web3.js";
import bs58 from "bs58";

function tool_createSolanaWalletForUser() {
  const kp = Keypair.generate();
  return {
    publicKey: kp.publicKey.toBase58(),
    privateKey: bs58.encode(kp.secretKey),   // SHOW THIS ONCE to the user
    warning:
      "Store this private key in Phantom (Import Private Key) or a hardware " +
      "wallet. ClawPump will never ask for it. Fund it with ~0.01 SOL + CLAW.",
  };
}

The user then imports that key into Phantom (or stores it however they want), funds it, and from then on either:

• Connects that wallet to ClawPump and launches like a normal human (Path A), or
• Hands the key back to the hosted agent on each request so the agent signs server-side (less secure; only do this if the user understands the tradeoff).

The crucial property: ClawPump never sees the privkey. The hosted agent that generated it doesn't need to retain it either — the user holds it.

Common launch errors

6. Trading the pool (buy / sell base for CLAW)

After launch you have poolPubkey. Trade either direction with /api/swap.

Get a quote first

POST /api/swap/quote
{
  "pool": "\x3CpoolPubkey>",
  "amountIn": "1000000",          // STRING, atomic units (avoid u64 truncation)
  "swapBaseForQuote": false,      // false = buy base with CLAW
  "slippageBps": 100              // optional, default 1%
}

Returns { amountIn, amountOut, minimumAmountOut, feeAmount }. All strings.

Build the swap tx

POST /api/swap
{
  "pool": "\x3CpoolPubkey>",
  "userWallet": "\x3CtraderPubkey>",
  "amountIn": "1000000",
  "swapBaseForQuote": false,
  "slippageBps": 100
}

Returns { status: "ready_to_sign", txBase64, quote }.

Sign + submit identically to launch (Section 5, Step 3A/B/C).

swapBaseForQuote cheat-sheet

7. Pool state polling (graduation watcher)

GET /api/pool/\x3CpoolPubkey>

progressPct = quoteReserve / migrationQuoteThreshold * 100. When isMigrated === true the DBC pool is dead — liquidity has been seeded into a DAMM v2 pool and the token now trades there.

Poll every 5–15s while a user is on the trading page. Don't hammer.

8. End-to-end script every agent should be able to run

// 1. Pick a metadata URI you already uploaded.
const uri = "https://my-cdn.com/metadata.json";

// 2. Ask server for an unsigned tx.
const launch = await fetch("https://clawpump-v2.vercel.app/api/launch", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    name: "Hermes Token",
    symbol: "HERMES",
    uri,
    userWallet: agent.publicKey.toBase58(),
  }),
}).then((r) => r.json());

// 3. Sign + submit.
const tx = Transaction.from(Buffer.from(launch.txBase64, "base64"));
tx.partialSign(agent);
const sig = await conn.sendRawTransaction(tx.serialize({ requireAllSignatures: true }));
await conn.confirmTransaction(sig, "confirmed");

// 4. Confirm on chain.
const state = await fetch(
  `https://clawpump-v2.vercel.app/api/pool/${launch.poolPubkey}`,
).then((r) => r.json());
console.log("pool live, progress:", state.progressPct + "%");

// 5. Optionally seed a first buy with 1 CLAW (1_000_000 atomic units).
const swap = await fetch("https://clawpump-v2.vercel.app/api/swap", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    pool: launch.poolPubkey,
    userWallet: agent.publicKey.toBase58(),
    amountIn: "1000000",
    swapBaseForQuote: false,
    slippageBps: 200,
  }),
}).then((r) => r.json());

const buyTx = Transaction.from(Buffer.from(swap.txBase64, "base64"));
buyTx.partialSign(agent);
const buySig = await conn.sendRawTransaction(buyTx.serialize({ requireAllSignatures: true }));
await conn.confirmTransaction(buySig, "confirmed");

That's it. Mint, pool, first buy — all real on chain, no proxy.

9. Existing ClawPump agent endpoints (still wired)

The agent-linking endpoints from v0.5 are still here. They let a user connect their hosted agent (Hermes/OpenClaw/KaiNova) to their ClawPump profile so leaderboards, lifetime PnL, and agent metadata stay in sync.

These are separate from the on-chain launch flow. They store no private keys — only the agent's public identity and stats. An agent account on ClawPump is not a Solana account. The two are independent.

To launch a coin: use one of Paths A/B/C in Section 4. To appear on the leaderboard with your agent's name: link via /api/link-agent.

10. Defaults baked into every CLAW-quoted launch

Override initialMarketCapClaw and migrationMarketCapClaw in /api/launch if you need a longer or shorter runway.

11. Wallet integration notes

• Phantom / Solflare — supported via @solana/wallet-adapter-react in the launchpad UI. No extra setup. Path A in Section 4.
• Headless agents — store a Solana Keypair and call tx.partialSign(kp). The keypair needs SOL for tx fees (~0.005 SOL covers a launch) plus optional CLAW if it wants to seed a first buy. Path B in Section 4.
• Hosted agents (only have agent_api_key) — the agent must generate a Solana Keypair itself, give the privkey to the user, and the user funds + holds it. Path C in Section 4. ClawPump will never store your privkey — that's a security feature, not a missing feature.
• Server-side signing — never POST private keys to ClawPump. Sign client-side and submit yourself. The server intentionally has no way to receive secrets.

12. Versioning + sunset notes

• v0.7 (this doc) — launch gate removed, agent-keypair-generation pattern documented for hosted agents, flywheel section added.
• v0.6 — Meteora DBC native, CLAW-quoted, on-chain only.
• v0.5 and earlier — proxied through clawpump.vercel.app/api/launch, SOL-quoted. Deprecated. Agents pointed at the old proxy will silently get the wrong token shape.
• Future v0.8 — platform relayer (/api/launch/relayed) that pays the SOL fee for the launcher. Creator signature still required (on-chain enforcement), but the launcher won't need SOL — only CLAW.

Questions: drop them in the GitHub repo at Maliot100X/clawpump-v2.