labs

Why people use it

Related MCP server: Pump.fun MCP Server

Connect in 30 seconds

https://labs.levercoin.lol/mcp

Streamable HTTP. No API key.

• Claude — Settings → Connectors → Add custom connector

• ChatGPT — Settings → Connectors → Advanced → Add

• Grok — add it as a custom MCP server

Then: “Launch a token on pump.fun called …”

Buy $LEVERCOIN, launch for free

Hold 0.25 SOL worth of $LEVERCOIN in the wallet that would have paid, and labs drops the fee transaction. It reads the balance. It does not transfer the tokens. Keep holding until the launch lands — submit checks the same amount again.

Tools

How a launch works

launch_token builds up to five transactions and stores them unsigned:

They go out as a single Jito bundle, which lands all-or-none. That is what makes the SOL fee unavoidable when it is present: the launch cannot reach the chain without it. It is also why only three extra buyers fit — a Jito bundle holds five transactions.

The fee is its own transaction rather than an instruction appended to the create. Both venues hand back an already-compiled transaction, and injecting an instruction would mean re-deriving its address lookup tables.

You open /sign/<bundleId>, connect each wallet in turn, and sign. The server re-verifies every signature against the exact message it handed out, re-reads the fee transaction to confirm it still pays the treasury, and only then submits. A signer can refuse, but cannot rewrite what they were given.

Holding $LEVERCOIN instead of paying

Set LEVER_MINT and the fee becomes a hold rather than a payment. When the wallet that would have paid already owns LABS_FEE_SOL worth of that mint, transaction 0 is left out and the bundle is one shorter. The tokens are never transferred: labs reads the associated token accounts and prices them against SOL in USD.

The required token amount is written onto the stored launch, and submit re-reads the balance against that same number instead of repricing. A wallet cannot qualify and then sell before the launch lands, and a price move during the 15-minute signing window cannot raise the bar after the fact. Selling below it rejects the submit, and building again charges SOL.

The two venues

pump.fun goes through PumpPortal's trade-local, which returns a compiled create and one compiled buy per wallet.

StonkFun has no launch endpoint — paidLaunchesEnabled is off, and launchLabEnabled is on. So labs builds the Raydium LaunchLab initialize_with_token_2022 itself against StonkFun's platform id, and StonkFun adopts the pool about a minute later. Standard mode only: a reward-mode launch writes a transfer-fee extension whose withheld tax cannot be recovered if the pool is never adopted. Call stonks_pairs first — a StonkFun token trades against another token, not necessarily SOL.

Metadata

pump.fun's /api/ipfs no longer accepts uploads and answers server-side requests with a block page, so metadata is resolved one of three ways:

1. a metadataUri you pass in, used as-is;

2. pinned to IPFS via Pinata, if LABS_PINATA_JWT is set — use this in production;

3. otherwise served by labs at /api/metadata/<id>, which only lasts as long as this deployment does.

The URI is written into the token permanently, so option 3 returns a warning, and labs refuses the launch if it cannot fetch its own URI back — that catches a misconfigured LABS_SITE_URL before a token is minted pointing at nothing.

The quoter

Off unless LABS_MAKER_ENABLED=true.

One disclosed wallet holds a bid and an ask around its own fair-value anchor. It buys when the price falls through the bid, sells when it rises through the ask, and does nothing in between — so the band has to be crossed before anything trades. Spread is floored at 50 bps, refresh at 15 seconds, duration at 24 hours. Inventory caps shrink size on whichever side the wallet is already heavy and stop that side at the cap.

It runs as a Vercel Workflow: one "use step" quote pass, then a durable sleep, so a 24-hour session costs nothing while it waits and survives a deploy. The workflow function itself touches no Node modules — it only orchestrates.

The maker approves a session in the browser. A throwaway quoting key is generated there, the wallet signs a plain-text approval naming the exact mint, spread and SOL cap, and only that key reaches the server, encrypted with LABS_SESSION_SECRET. It expires, and stop_maker discards it early.

Running it

npm install
cp .env.example .env.local   # LABS_TREASURY is required
npm run dev
npx workflow web             # inspect quoter runs

LABS_SITE_URL must be the public URL in production; it is baked into signing links and into metadata URIs. Launch bundles fall back to in-memory storage without Redis, which is fine for next dev, but maker sessions refuse to start without it because each workflow step resumes in a new invocation.

Deploy to Vercel as its own project with its own env; it shares nothing with the levercoin marketing site.

Checking what is live

Production is main only, and main takes pull requests: direct pushes are rejected, and every PR runs typecheck and next build.

Three surfaces report the same commit, so nobody has to trust the badges:

curl -s https://labs.levercoin.lol/api/status | jq '{version, sha, store}'

Take the sha and open https://github.com/koynlabs/labs-mcp/commit/<sha>. If it resolves to a commit on main, the deployment is this source.

Status is read from the running process — the build's commit and the env it booted with. It is deliberately not an HTTP probe of /mcp: that would pay a cold start on the heaviest route in the app every time a badge refreshed.

The Grok bot Rive lives at public/demo and is served at /demo after deploy.

Known limits

• Three extra buyer wallets per launch, from the five-transaction Jito limit.

• StonkFun launches are standard mode only.

• The quoter supports pump.fun only. StonkFun quoting is refused rather than guessed at, because an existing LaunchLab pool's state is not in the launch-time pricing response.

• PumpPortal rejects a bundle if it dislikes any one wallet and does not say which, so launch_token lists the buyers back in that error.

License

MIT. The code is public so you can verify that a launch is signed by your wallet and that the server never holds that key. Secrets (LABS_TREASURY, LABS_PINATA_JWT, LABS_SESSION_SECRET, Redis) stay in the deployment env and are not in this repo.