Highwire MCP Server

Highwire

The agent wire for higher.fun. Highwire is an MCP server that lets AI agents use higher.fun, the open-source Solana launchpad. Lower Fees, Higher Together.

Live at highwire.fun. Follow @Highwiredotfun on X.

Agents can scan launches and trending coins, pull a coin's trades, holders, candles and safety data, look up creators and their earnings, and run a rug check, all from the public higher.fun API and Solana RPC. No keys needed.

Sign from any chat. Highwire quotes trades and builds buys, sells, coin launches and creator fee claims as unsigned transactions, hosted or local. Each comes with a sign_url: open it, and highwire.fun/sign re-checks and simulates the transaction in your browser, then your own wallet signs. Highwire never signs, never holds a key and never sends anything. See docs/ROADMAP.md.

Or let your agent act, inside your rules. The local server has an opt-in signer: point it at a keypair file on your machine, write a policy (actions, coins, slippage, SOL per transaction and per day, transfer recipients), and the execute tools sign and send only inside it. Dry run until the policy says "live": true. See Local signer.

Tools

Transactions (hosted and local):

Every build tool decodes its own transactions into plain-language lines, checks them the way higher.fun's site does, simulates them, tags each with a highwire memo, and returns a sign_url. The output format, the sign links and the sign page are in docs/unsigned-transactions.md.

Local only:

The sign page (highwire.fun/sign) reads the transaction from the link's fragment, which never reaches a server, decodes every instruction from the bytes, shows what you spend and receive, the fees, the fee payer and the expiry, simulates against a Solana RPC straight from the browser, and signs with Phantom, Solflare, Backpack or any Wallet Standard wallet. It refuses anything off the allow-list, an expired blockhash, a failed simulation or the wrong wallet, and sends nothing to Highwire. Trade and claim links last up to 10 minutes (the page refreshes the blockhash and changes nothing else); launch links, whose new mint is already signed, about a minute.

Safety:

• Highwire never asks for, accepts or stores a private key or seed phrase. The user signs in their own wallet.
• Every instruction must be one Highwire builds, for the signing wallet's own accounts, on higher.fun's platform configs and fee tier. The launch fee must go to the fee wallet recorded on-chain and be at most 0.05 SOL. A transaction that fails a check is never returned; one that fails simulation comes back as an error.
• Caps: max_slippage_bps at most 1500, and no transaction moves more than HIGHWIRE_MAX_SOL_PER_TX (10 SOL by default).
• A launch's new mint is fixed per idempotency_key, so a retry reuses it and the coin (and its fee) can only happen once. The mint is derived with HMAC-SHA256 from a secret, the key and the launch (cluster, wallet, name, ticker, fee mode), so the same retry gets the same mint on any hosted instance or after a local restart, and once the coin exists a retry returns already_launched. The hosted endpoint uses HIGHWIRE_LAUNCH_SECRET; the highwire CLI uses it when set, and otherwise a random secret it creates once in ~/.highwire/launch-secret. Reusing a key for a different coin gets a different mint.
• If the coin was created but its creator lock was never assigned (the launch's second transaction expired or failed), a retry with the same key builds just the assignment.
• higher.fun's image and metadata upload needs a wallet sign-in, so build_launch takes a hosted metadata_uri. Without one it returns the metadata JSON to host. With the local signer, execute_launch takes image_path instead: the signer signs higher.fun's sign-in message (checked word for word, and nothing else), uploads the image and metadata, and launches. Only a real PNG, JPEG, GIF or WebP of at most 4 MB is uploaded, and never a file from the signer's folder.
• execute_launch also takes launch_for (New school): an X or GitHub handle. higher.fun resolves it to the wallet that holds that account's creator fees until they claim at higher.fun/claim; the coin is created for that wallet, which gets 0.005 SOL from you if it holds less, and your first buy is still yours. The sign page never signs a launch for someone else, so this needs the local signer. higher.fun hasn't switched the lookup on yet (it answers "isn't switched on yet"); until it does, execute_launch stops with launch_for_unavailable before uploading or spending anything.

Prompts:

• scan_launches
• coin_due_diligence
• creator_report
• plan_launch

Resources:

• higher://platform
• higher://coins/{mint}

Skill: an operator guide for agents is in packages/mcp/skills/highwire/SKILL.md.

Connect

Hosted

Nothing to install, no key. The hosted server has all 26 tools; the build tools only return unsigned transactions and a sign link.

Claude Code

claude mcp add --transport http highwire https://highwire.fun/mcp

Cursor, or any client that takes a remote MCP URL

{
  "mcpServers": {
    "highwire": { "url": "https://highwire.fun/mcp" }
  }
}

The endpoint speaks stateless Streamable HTTP: POST JSON-RPC, get JSON back. Each IP gets 60 units a minute: a build tool or watch_market call costs 5, a few heavy reads 2 to 10, anything else 1.

Local (stdio)

Needs Node 20 or later; live alerts (watch_market, highwire watch) need Node 22, for its built-in WebSocket.

Claude Code

claude mcp add highwire -- npx -y highwire-mcp

Claude Desktop, Cursor, or any stdio client

{
  "mcpServers": {
    "highwire": {
      "command": "npx",
      "args": ["-y", "highwire-mcp"],
      "env": { "SOLANA_RPC_URL": "https://api.mainnet-beta.solana.com" }
    }
  }
}

Environment variables. All are optional; see .env.example.

The site (apps/web) also reads NEXT_PUBLIC_SOLANA_RPC_URL and NEXT_PUBLIC_SOLANA_DEVNET_RPC_URL, the RPCs the sign page calls from the browser, and allows only their origins in its CSP. The public RPC is rate-limited, and the public mainnet endpoint refuses requests from web pages (HTTP 403), so the deployed site needs its own mainnet RPC there. For anything beyond light use, set SOLANA_RPC_URL to your own too (Helius, Triton, …).

Live alerts in the terminal

npx -y highwire-mcp watch --min-sol 1

prints higher.fun's live feed, one line an event, until Ctrl-C. --launches, --graduations, --buys and --sells pick what to show (all four by default), --mint keeps one coin's trades and graduations and adds each trader's wallet (repeat it for up to 16 coins), --min-sol drops small trades, and --json prints JSON lines instead.

Launch on your own

An agent with a shell can launch coins and collect their fees from its own wallet, with no one in the loop once it's set up. highwire.fun/skill.md walks an agent through it ("Read highwire.fun/skill.md and launch a coin"):

npx -y highwire-mcp wallet new                  # ~/.highwire/wallet.json, readable only by you; prints the address to fund
npx -y highwire-mcp policy init --launch --live # mainnet launches and claims, 0.25 SOL a launch, 0.5 SOL a day
npx -y highwire-mcp launch --name "Cat Demo" --ticker CATDEMO --image ./cat.png --buy 0.02
npx -y highwire-mcp claim                       # the creator fees

launch signs in to higher.fun with the wallet, uploads the image and metadata, and launches through execute_launch, so the policy, the simulation and the audit log apply as they do for the tool. The launching wallet is the coin's creator, so the creator fees go to it. A retry with the same wallet, name, ticker and mode finds its coin instead of launching a second one. wallet new never overwrites a wallet or prints the key; policy init never replaces a policy. wallet, launch and claim use HIGHWIRE_KEYPAIR_PATH instead of wallet.json when it's set.

Launch ideas

highwire.fun/ideas has ideas for agents to launch and run, each with a full PRD and a template repository: Deploy to GitHub creates it in your account, with Highwire wired in, a dry-run policy and instructions for your coding agent. Or skip GitHub's form:

npx -y highwire-mcp new                 # list the ideas
npx -y highwire-mcp new dip-buyer       # write one into ./dip-buyer, and git init

The ideas are a buyback coin, a dip buyer, a launch scout, a community treasury and fee-funded compute. They and the starter live in ideas/, and ship in the highwire-mcp package for highwire new.

Local signer

Off unless you turn it on, and never on the hosted endpoint. It signs only inside a policy you write in ~/.highwire/policy.json, which no tool can change.

npx -y highwire-mcp policy init

writes a starting policy: devnet, dry run, trades and claims, 0.1 SOL a transaction, 0.5 SOL a day. Then set HIGHWIRE_KEYPAIR_PATH in the local server's env to a Solana CLI keypair file. Use a wallet that holds only what you'd let an agent spend.

Every execute is written to ~/.highwire/audit.jsonl: refusals, dry runs, and each signature as it's sent. Creating ~/.highwire/STOP refuses everything until you delete it. HIGHWIRE_HOME and HIGHWIRE_POLICY_PATH move the files.

Standing orders. With "orders": {"kinds": ["stop_loss", "take_profit", "limit_buy", "recurring_buy"]} in the policy, an agent can place orders with place_order, which wait in ~/.highwire/orders.json:

• stop_loss sells a share of the wallet's coin once its price falls to a trigger (trigger_price_sol, or trigger_change_pct from now), and take_profit once it rises to one. min_sol_out makes either wait rather than sell for less.
• limit_buy buys sol of the coin once its price falls to a trigger (trigger_price_sol, or a negative trigger_change_pct), once. highwire orders limit-buy --mint <mint> --sol 0.1 --drop-pct 30 places one from the shell.
• recurring_buy buys sol every every_hours, times times.
• fee_claim claims the wallet's creator fees every every_hours when at least min_claim_sol is waiting (default 0.001 SOL), and with buyback_pct and mint spends that share of the SOL each claim brought in buying the coin. It needs claim in the policy's actions, and trade too for buybacks. highwire orders claim --every-hours 24 [--buyback-pct 50 --mint <mint>] places one from the shell, and policy init --launch allows it.

They fill only while this runs, with the same HIGHWIRE_KEYPAIR_PATH (one runner at a time):

HIGHWIRE_KEYPAIR_PATH=~/.config/solana/agent.json npx -y highwire-mcp orders run

Price orders are checked against the coin's on-chain price every minute, and within seconds of a trade on it (the live feed only says when to look). Each fill passes the whole policy again, dry run included, is simulated and is written to the audit log with its order's id. A fill the runner can't be sure about (it stopped mid-fill, or the send's answer was lost) closes the order as failed rather than risk filling it twice; a fee claim whose answer was lost just waits for its next run, since claiming again is harmless, but its buyback closes the order. highwire orders list and highwire orders cancel <id> work without the keypair.

Posting. With a posts section, post_comment and post_chat (or highwire post --mint <mint> "…" and highwire post --chat "…") post on higher.fun as the wallet: the signer signs higher.fun's sign-in message, and the post goes up under the wallet's name. Plain text only: links, web addresses and wallet or mint addresses are refused, since chat is where phishing lives. Each post is written to the audit log before it goes up, counts against max_per_day whether or not the answer comes back, and is a dry run until the policy is live.

Repository

An npm workspaces monorepo.

Development

git clone https://github.com/HigherMaestro/highwire.git

cd highwire && npm install

Every command runs from the root and covers all workspaces.

To point the hosted check at a deployed site instead of next dev:

SMOKE_URL=https://highwire.fun npm run smoke -w highwire-web

Deploying

The site runs on Vercel (project highwire, root directory apps/web, Node 22), connected to this repository: every push to main deploys production. The project needs NEXT_PUBLIC_SOLANA_RPC_URL (a mainnet RPC that accepts browser requests from highwire.fun; it is public, so use a key restricted to that origin), SOLANA_RPC_URL (the server-side RPC the build tools and get_wallet_pnl use; it must be able to search transaction history), and HIGHWIRE_LAUNCH_SECRET (a long random string; changing it changes the mint of any launch still being retried).

To deploy without a push, run this from the repo root, never from a package folder (that makes a new Vercel project):

vercel deploy --prod --scope groovys-projects

.vercelignore keeps local-only files out of a CLI upload. www.highwire.fun redirects to highwire.fun. After a deploy, run the hosted smoke check above.

To run a local build over stdio, npm run build, then use node /path/to/highwire/packages/mcp/dist/cli.js as the command.

AGENTS.md has the conventions. docs/higher-reference.md has everything known about higher.fun's programs, fee modes and API, with sources.

Support

Trades that Highwire builds on mainnet carry a 0.3% fee: 0.3% of the SOL paid in on a buy, or of the minimum SOL out on a sell, as one transfer inside the same transaction, shown in its summary and on the sign page. Launches, claims and transfers carry none, and Highwire never takes any of a coin's creator fees. The fee, and any donation, goes to Highwire's only wallet, 7LnP9W1BcRhGRtUgSweGbGndaKaRmQxKVtCEHTeW7Rce (Solscan). No other wallet collects for Highwire, there is no Highwire token, and we never ask for funds in DMs.

Licence

MIT.