AI agent'larının Solana üzerindeki higher.fun coin'lerini imzasız işlemler veya yerel bir politika imzalı signer kullanarak alıp satmasına, yeni coin çıkarmasına ve araştırmasına olanak tanır.
Ayrıca bilinen adı HigherMaestro/highwire, highwire-mcp
- Yıldızlar
- 0
- Araçlar
- 34
- İndirmeler, 30 gün
- —
- En son sürüm
- 0.19.0
- Son commit
- 15 Kas 2026
- Lisans
- MIT
Highwire MCP nedir?
AI agent'larının Solana üzerindeki higher.fun coin'lerini imzasız işlemler veya yerel bir politika imzalı signer kullanarak alıp satmasına, yeni coin çıkarmasına ve araştırmasına olanak tanır. 34 araç sunar; örneğin list_coins, search_coins, get_coin.
Özet, projenin README dosyasından oluşturuldu
Highwire MCP sunucusu hakkında
Highwire, AI agent'larının higher.fun Solana launchpad ile etkileşime girmesi için bir arayüz sağlar. Agent'ların piyasa araştırması yapmasına, trend olan coin'leri taramasına ve yaratıcı kazançlarını veya holder yoğunluğunu analiz etmesine olanak tanır. Geliştiriciler, herhangi bir API key gerektirmeden uzak bir URL üzerinden barındırılan sürümü kullanabilir veya daha gelişmiş yetenekler için stdio kullanarak yerel bir sürüm çalıştırabilir. Barındırılan uç nokta 27 aracın tamamını sağlar ancak yalnızca kullanıcı onayı için imzasız işlemleri imza bağlantıları aracılığıyla döndürür.
Otomasyon gerektiren kullanıcılar için yerel sunucu, yerel bir keypair ve özel bir politika kullanan isteğe bağlı bir signer destekler. Bu politika, agent'ların slippage, günlük SOL limitleri ve onaylı alıcılar gibi belirli kısıtlamalar dahilinde işlem yapmasına, yeni coin çıkarmasına ve fee claim işlemlerini gerçekleştirmesine olanak tanır. Sistem, sunucunun asla özel anahtarları tutmamasını sağlayarak güvenliğe öncelik verir; bunun yerine işlemler simüle edilir ve kullanıcı tarafından tarayıcı tabanlı bir arayüz veya yerel politika güdümlü signer aracılığıyla imzalanır.
Neler yapabilirsiniz
- 1Coin incelemesi yapmaBir AI agent, belirli bir coin'in güvenlik derecesini, holder yoğunluğunu ve son işlem geçmişini analiz edebilir.
- 2Güvenlik kurallarıyla ticareti otomatikleştirmeBir geliştirici, bir agent'ın önceden tanımlanmış slippage ve harcama limitleri dahilinde işlemleri otomatik olarak gerçekleştirmesine izin vermek için yerel bir signer kurabilir.
Projenin README dosyasından alınmıştır. Her kullanım durumu, oradaki bir alıntı ile kontrol edilir.
Highwire MCP nasıl yüklenir
Biçimler 10 Kas 2026 tarihinde doğrulandıCursor'a ekleGoose'a ekleHighwire MCP'yi Claude Code içine yükleyin
$ claude mcp add --env 'SOLANA_RPC_URL=<YOUR_SOLANA_RPC_URL>' highwire -- npx -y highwire-mcpHighwire MCP'yi Cursor içine yükleyin
~/.cursor/mcp.json
{
"mcpServers": {
"highwire": {
"command": "npx",
"args": [
"-y",
"highwire-mcp"
],
"env": {
"SOLANA_RPC_URL": "<YOUR_SOLANA_RPC_URL>"
}
}
}
}Highwire MCP'yi VS Code içine yükleyin
.vscode/mcp.json
{
"servers": {
"highwire": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"highwire-mcp"
],
"env": {
"SOLANA_RPC_URL": "<YOUR_SOLANA_RPC_URL>"
}
}
}
}Highwire MCP'yi VS Code CLI içine yükleyin
$ code --add-mcp '{"name":"highwire","type":"stdio","command":"npx","args":["-y","highwire-mcp"],"env":{"SOLANA_RPC_URL":"<YOUR_SOLANA_RPC_URL>"}}'Highwire MCP'yi Claude Desktop içine yükleyin
claude_desktop_config.json
{
"mcpServers": {
"highwire": {
"command": "npx",
"args": [
"-y",
"highwire-mcp"
],
"env": {
"SOLANA_RPC_URL": "<YOUR_SOLANA_RPC_URL>"
}
}
}
}Highwire MCP'yi Codex içine yükleyin
$ codex mcp add highwire --env 'SOLANA_RPC_URL=<YOUR_SOLANA_RPC_URL>' -- npx -y highwire-mcpHighwire MCP'yi Codex config.toml içine yükleyin
~/.codex/config.toml
[mcp_servers.highwire] command = "npx" args = ["-y", "highwire-mcp"] [mcp_servers.highwire.env] SOLANA_RPC_URL = "<YOUR_SOLANA_RPC_URL>"
Highwire MCP'yi Gemini CLI içine yükleyin
$ gemini mcp add -s user -e 'SOLANA_RPC_URL=<YOUR_SOLANA_RPC_URL>' highwire npx -- -y highwire-mcpHighwire MCP'yi Gemini settings.json içine yükleyin
~/.gemini/settings.json
{
"mcpServers": {
"highwire": {
"command": "npx",
"args": [
"-y",
"highwire-mcp"
],
"env": {
"SOLANA_RPC_URL": "<YOUR_SOLANA_RPC_URL>"
}
}
}
}Highwire MCP araçları 34
README dosyasından algılandılist_coinssearch_coinsget_coinget_coin_tradesget_coin_holdersget_coin_candlesget_coin_commentsget_trade_tapewatch_marketget_top_coinsget_leaderboardget_featured_coin
| list_coins | — | |
| search_coins | — | |
| get_coin | — | |
| get_coin_trades | — | |
| get_coin_holders | — | |
| get_coin_candles | — | |
| get_coin_comments | — | |
| get_trade_tape | — | |
| watch_market | — | |
| get_top_coins | — | |
| get_leaderboard | — | |
| get_featured_coin | — |
34 aracın tümünü gösterDaha az araç göster
get_chatget_wallet_profileget_creator_coinsget_platform_infocheck_tickerrug_checkget_ecosystem_feesget_coin_feesget_creator_feesquote_tradeget_wallet_positionsget_wallet_pnlbuild_tradebuild_launchbuild_claim_creator_feesbuild_transferget_signer_statusscan_launchescoin_due_diligencecreator_reportplan_launchhigher
| get_chat | — | |
| get_wallet_profile | — | |
| get_creator_coins | — | |
| get_platform_info | — | |
| check_ticker | — | |
| rug_check | — | |
| get_ecosystem_fees | — | |
| get_coin_fees | — | |
| get_creator_fees | — | |
| quote_trade | — | |
| get_wallet_positions | — | |
| get_wallet_pnl | — | |
| build_trade | — | |
| build_launch | — | |
| build_claim_creator_fees | — | |
| build_transfer | — | |
| get_signer_status | — | |
| scan_launches | — | |
| coin_due_diligence | — | |
| creator_report | — | |
| plan_launch | — | |
| higher | — |
Yapılandırma
SOLANA_RPC_URLGizliYour Solana RPC URL; defaults to the public one
HIGHWIRE_CLUSTERmainnet (default) or devnet
HIGHWIRE_KEYPAIR_PATHA keypair file, to turn on the local signer (it signs only inside your policy)
SMOKE_URL
| Ad | Açıklama | Sunucu |
|---|---|---|
| SOLANA_RPC_URL | Your Solana RPC URL; defaults to the public one | Gizli |
| HIGHWIRE_CLUSTER | mainnet (default) or devnet | |
| HIGHWIRE_KEYPAIR_PATH | A keypair file, to turn on the local signer (it signs only inside your policy) | |
| SMOKE_URL | — |
Otomatik kontroller
Çalıştırıldı 12 Kas 2026Tam rapor →Otomatik kontrollerimizden geçti. Bu bir güvenlik denetimi değildir: kodu okuyun ve sunucuya ihtiyaç duyduğu en dar erişimi verin. Kontroller nasıl çalışır
- Kaynak deposu bağlantılı ve erişilebilirGeçti
- Açık kaynak lisansı (OSI)Geçti
- Son bir yıl içinde commit veya sürüm mevcutGeçti
- Paket adı popüler bir pakete yakın değilGeçti
- Uzak uç nokta HTTPS kullanıyorGeçti
- Yıkıcı araçlar etiketlenmişGeçti
- Modele yönelik gizli talimat yokGeçti
- Pakette veya bağımlılıklarında kritik uyarı yokGeçti
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
| Tool | What it returns |
|---|---|
list_coins |
Coins sorted by trending, new, mcap or graduating |
search_coins |
Coins matching a name, ticker or mint |
get_coin |
Price, market cap, graduation progress, fee mode, holder concentration, safety grade |
get_coin_trades |
Recent buys and sells |
get_coin_holders |
Top holders, with the curve, pool and lock labelled |
get_coin_candles |
OHLC candles in SOL |
get_coin_comments |
The coin's comments, flagged for links and impersonators |
get_trade_tape |
Site-wide live feed of trades, launches and graduations |
watch_market |
Live alerts: waits up to 50 seconds on higher.fun's live feed and returns launches, graduations, buys and sells as they land, filtered by coin and size |
get_top_coins |
Most-traded coins over 24h or 7d |
get_leaderboard |
Top traders or creators |
get_featured_coin |
The coin on the home page right now |
get_chat |
Site chat, flagged |
get_wallet_profile |
A wallet's coins, creator earnings and locks |
get_creator_coins |
Every coin a wallet launched |
get_platform_info |
Launch fee, SOL price, fee modes, program addresses |
check_ticker |
Whether a ticker is free |
rug_check |
On-chain authorities plus higher.fun's safety data, rolled into a verdict |
get_ecosystem_fees |
Every fee higher.fun's coins have paid and who got it, by phase and fee mode, what's waiting to be claimed, and the top coins: the numbers behind highwire.fun/fees |
get_coin_fees |
One coin's fees, line by line: who got each, measured on-chain or computed from volume, and what's waiting |
get_creator_fees |
What a creator wallet's coins have paid it, coin by coin, and what's waiting for it to claim |
Transactions (hosted and local):
| Tool | What it does |
|---|---|
quote_trade |
Quote a buy (SOL in) or sell (tokens in) on the curve or, after graduation, the CPMM pool: output, minimum out, price impact, fees split by fee mode |
get_wallet_positions |
A wallet's SOL and its higher.fun coins (recognised on-chain), valued at the last price |
get_wallet_pnl |
Profit and loss on a wallet's coins from its own transactions on-chain: average cost, realized and unrealized, through any app. Needs an RPC that can search history |
build_trade |
The trade as an unsigned transaction. Needs confirm_trade: true, max_slippage_bps (at most 1500) and max_sol |
build_launch |
Create a coin (Old or New school), pay the launch fee after checking its treasury, optional first buy and creator lock. Needs confirm_launch: true and an idempotency_key |
build_claim_creator_fees |
Claim curve creator fees and graduated pools' creator fees; reports the off-chain locked-LP payouts. Needs confirm_claim: true |
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:
| Tool | What it does |
|---|---|
build_transfer |
SOL or a higher.fun coin to another wallet, unsigned. No sign_url: the sign page never signs transfers |
get_signer_status |
With the local signer: its wallet, live or dry run, the policy, and what's left of today's limit |
execute_trade, execute_launch, execute_claim, execute_transfer |
With the local signer: build exactly what the build tool builds, check the policy, simulate again, then sign and send (or dry-run) |
place_order, list_orders, cancel_order |
With the local signer: standing orders (stop-loss, take-profit, limit buys, recurring buys, fee claims) that highwire orders run fills inside the policy |
post_comment, post_chat |
With the local signer: post a comment on a coin or a message in higher.fun's chat as the wallet, inside the policy's posts section |
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_bpsat most 1500, and no transaction moves more thanHIGHWIRE_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 returnsalready_launched. The hosted endpoint usesHIGHWIRE_LAUNCH_SECRET; thehighwireCLI 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_launchtakes a hostedmetadata_uri. Without one it returns the metadata JSON to host. With the local signer,execute_launchtakesimage_pathinstead: 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_launchalso takeslaunch_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_launchstops withlaunch_for_unavailablebefore uploading or spending anything.
Prompts:
scan_launchescoin_due_diligencecreator_reportplan_launch
Resources:
higher://platformhigher://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 27 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.
| Variable | Default |
|---|---|
HIGHER_API_URL |
https://api.higher.fun |
HIGHWIRE_CLUSTER |
mainnet; devnet quotes and builds on higher.fun's devnet deployment (the API, and so the research tools, stay on mainnet) |
SOLANA_RPC_URL |
the cluster's public RPC, https://api.mainnet-beta.solana.com on mainnet |
HIGHWIRE_MAX_SOL_PER_TX |
10: the most SOL one built transaction may spend or return |
HIGHER_TIMEOUT_MS |
15000 |
HIGHER_RETRIES |
2 |
HIGHWIRE_SITE_URL |
https://highwire.fun: where sign_url points; http://localhost:3000 for a local site |
HIGHWIRE_LAUNCH_SECRET |
the secret launch mints are derived from. Unset, the CLI creates one in ~/.highwire/launch-secret |
HIGHWIRE_RATE_LIMIT |
60 units a minute per IP; a build costs 5 (hosted endpoint only) |
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.
Modules add one thing to an agent you already run, as working code with a short spec: dip buys, receipts on the
coin's page, and a kill switch that creates STOP when the wallet signs something Highwire didn't send, spends too
fast or keeps failing. In your project:
npx -y highwire-mcp add # list the modules
npx -y highwire-mcp add kill-switch # copy it in, then wire it into src/agent.ts as modules/kill-switch.md says
It never overwrites a file and never changes your policy. They live in ideas/modules.
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.
| Policy key | What it limits |
|---|---|
cluster |
mainnet or devnet, required |
live |
false by default: every execute is a dry run that signs nothing |
actions |
any of trade, launch, claim, transfer |
max_sol_per_tx, max_sol_per_day |
SOL spent on trades, launch fees and first buys, and SOL sent. Each transaction may also spend up to 0.03 SOL on rent and fees, Highwire's 0.3% trade fee included. Both limits count what the simulation shows actually leaving the wallet, rent and fees included, when that's more. The day is the last 24 hours, counted from the audit log |
max_slippage_bps |
for trades and first buys |
coins |
allow or deny lists of mints. Before going live, list the coins (or creators) you mean the agent to trade: without an allow-list it may buy any higher.fun coin within your limits, and the signer warns you so |
creators |
allow: only coins launched by these wallets |
transfer_allowlist |
the only recipients for execute_transfer |
orders |
kinds: the standing orders an agent may place (stop_loss, take_profit, limit_buy, recurring_buy, fee_claim), and max_open (default 10). Without it, none |
posts |
comments: own (the default: only coins the wallet launched), any or none; chat: true to allow higher.fun's site chat (default false); max_per_day (default 10, comments and chat together). Mainnet only. Without it, none |
send |
route: rpc (the default) or jito, which sends trades and claims through Jito's block engine as one-transaction bundles, so they can't be sandwiched and one that would fail costs nothing (mainnet only); max_tip_sol, the most one send tips (default 0.0005, at most 0.01; it counts against the limits like any spend); fallback: none (the default: if Jito refuses, nothing is sent) or rpc. Launches and transfers always go the ordinary way. See docs/protected-sends.md |
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_losssells a share of the wallet's coin once its price falls to a trigger (trigger_price_sol, ortrigger_change_pctfrom now), andtake_profitonce it rises to one.min_sol_outmakes either wait rather than sell for less.limit_buybuyssolof the coin once its price falls to a trigger (trigger_price_sol, or a negativetrigger_change_pct), once.highwire orders limit-buy --mint <mint> --sol 0.1 --drop-pct 30places one from the shell.recurring_buybuyssoleveryevery_hours,timestimes.fee_claimclaims the wallet's creator fees everyevery_hourswhen at leastmin_claim_solis waiting (default 0.001 SOL), and withbuyback_pctandmintspends that share of the SOL each claim brought in buying the coin. It needsclaimin the policy'sactions, andtradetoo for buybacks.highwire orders claim --every-hours 24 [--buyback-pct 50 --mint <mint>]places one from the shell, andpolicy init --launchallows 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. A fee claim with a buyback claims
and buys in one transaction when they fit, so neither lands without the other; on Jito's route, a send that provably
never landed (refused, or its blockhash expired unseen) costs nothing and the order simply tries again. 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.
| Path | What it is |
|---|---|
| packages/core | highwire-core: the higher.fun API client, constants, unit formatting, the rug check, and the quote and transaction builders |
| packages/agent | highwire-agent: the opt-in local signer: the policy, the keypair loader, the audit log and the executor |
| packages/mcp | highwire-mcp: the MCP server, the highwire stdio bin and a stateless HTTP handler |
| apps/web | The Next.js site: the sign page at /sign, /docs, /ideas, /fees, /changelog, /terms, /privacy, the hosted MCP at /mcp and GET /api/health |
| ideas | Launch ideas: the starter skeleton and one folder per idea, assembled into template repositories, and modules/, which highwire add copies into a project |
Development
git clone https://github.com/HigherMaestro/highwire.git
cd highwire && npm install
Every command runs from the root and covers all workspaces.
| Command | What it does |
|---|---|
npm run dev |
Run the MCP server from source over stdio |
npm run dev:web |
Run the site at http://localhost:3000, with the MCP at http://localhost:3000/mcp |
npm test |
Unit, in-memory MCP and HTTP handler tests, offline |
npm run simulate |
Build and simulate buys, sells, launches and claims on mainnet and devnet as public wallets, check each sign_url decodes, and print one for a buy; nothing is signed or sent |
npm run smoke |
Call every tool over stdio, then start next dev and check the pages, /sign's headers, /api/health and /mcp against the live API |
npm run typecheck |
Type-check every workspace |
npm run build |
Compile the packages to dist/ and build the site |
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.
Highwire MCP soruları
Highwire MCP'yi Claude Code'a nasıl eklerim?
Terminalinizde claude mcp add --env 'SOLANA_RPC_URL=<YOUR_SOLANA_RPC_URL>' highwire -- npx -y highwire-mcp komutunu çalıştırın. Her projede kullanılabilir olması için --scope user ekleyin.
Highwire MCP'yi Cursor'a nasıl eklerim?
~/.cursor/mcp.json dosyasını açın ve yukarıdaki yükleme bölümünde gösterilen Cursor yapılandırmasını kullanarak sunucuyu mcpServers altına ekleyin.
Highwire MCP hangi araçları sunar?
34 araç sunar; bunlar arasında list_coins, search_coins, get_coin, get_coin_trades, get_coin_holders yer alır.
Highwire özel anahtarlarımı tutuyor mu?
Hayır, Highwire asla imzalama yapmaz, anahtar tutmaz ve hiçbir şey göndermez. Kullanıcılar işlemleri kendi tarayıcılarında kendi cüzdanlarını kullanarak imzalarlar.
Belirli kurallarla işlemleri otomatikleştirebilir miyim?
Evet, yerel sunucu; aksiyonlar, coin'ler, slippage ve günlük SOL limitleri için bir politika tanımlayabileceğiniz isteğe bağlı bir signer içerir.