AI 에이전트가 서명되지 않은 트랜잭션 또는 로컬 정책 기반 서명자를 사용하여 Solana의 higher.fun 코인을 거래, 출시 및 조사할 수 있도록 합니다.
다른 이름 HigherMaestro/highwire, highwire-mcp
- 스타
- 0
- Tools
- 34
- 다운로드, 30일
- —
- 최신 버전
- 0.19.0
- 마지막 커밋
- 2026년 11월 15일
- 라이선스
- MIT
Highwire MCP란?
AI 에이전트가 서명되지 않은 트랜잭션 또는 로컬 정책 기반 서명자를 사용하여 Solana의 higher.fun 코인을 거래, 출시 및 조사할 수 있도록 합니다. 34개 도구를 제공합니다. 예: list_coins, search_coins, get_coin.
프로젝트 README에서 생성된 요약
Highwire MCP server 정보
Highwire는 AI 에이전트가 higher.fun Solana 런치패드와 상호작용할 수 있는 인터페이스를 제공합니다. 에이전트는 시장 조사, 트렌딩 코인 스캔, 크리에이터 수익 또는 홀더 집중도 분석을 수행할 수 있습니다. 개발자는 API 키 없이 원격 URL을 통해 호스팅 버전을 사용하거나, 더 고급 기능을 위해 stdio를 사용하는 로컬 버전을 실행할 수 있습니다. 호스팅 엔드포인트는 27개의 모든 도구를 제공하지만, 사용자의 승인을 위해 서명 링크를 통한 서명되지 않은 트랜잭션만 반환합니다.
자동화가 필요한 사용자의 경우, 로컬 서버는 로컬 키페어와 사용자 정의 정책을 사용하는 선택형 서명자를 지원합니다. 이 정책을 통해 에이전트는 슬리피지, 일일 SOL 한도, 승인된 수신자와 같은 특정 제약 조건 내에서 거래, 출시 및 수수료 청구를 실행할 수 있습니다. 이 시스템은 서버가 개인 키를 절대 보유하지 않도록 보장함으로써 보안을 최우선으로 합니다. 대신 트랜잭션은 시뮬레이션되며 브라우저 기반 인터페이스 또는 로컬 정책 기반 서명자를 통해 사용자가 직접 서명합니다.
활용 사례
- 1코인 실사 수행AI 에이전트가 특정 코인의 안전 등급, 홀더 집중도 및 최근 거래 내역을 분석할 수 있습니다.
- 2안전 규칙을 통한 거래 자동화개발자가 로컬 서명자를 설정하여 에이전트가 미리 정의된 슬리피지 및 지출 한도 내에서 자동으로 거래를 실행하도록 할 수 있습니다.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
Highwire MCP 설치 방법
형식 확인: 2026년 11월 10일Cursor에 추가Goose에 추가Claude Code에 Highwire MCP 설치
$ claude mcp add --env 'SOLANA_RPC_URL=<YOUR_SOLANA_RPC_URL>' highwire -- npx -y highwire-mcpCursor에 Highwire MCP 설치
~/.cursor/mcp.json
{
"mcpServers": {
"highwire": {
"command": "npx",
"args": [
"-y",
"highwire-mcp"
],
"env": {
"SOLANA_RPC_URL": "<YOUR_SOLANA_RPC_URL>"
}
}
}
}VS Code에 Highwire MCP 설치
.vscode/mcp.json
{
"servers": {
"highwire": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"highwire-mcp"
],
"env": {
"SOLANA_RPC_URL": "<YOUR_SOLANA_RPC_URL>"
}
}
}
}VS Code CLI에 Highwire MCP 설치
$ code --add-mcp '{"name":"highwire","type":"stdio","command":"npx","args":["-y","highwire-mcp"],"env":{"SOLANA_RPC_URL":"<YOUR_SOLANA_RPC_URL>"}}'Claude Desktop에 Highwire MCP 설치
claude_desktop_config.json
{
"mcpServers": {
"highwire": {
"command": "npx",
"args": [
"-y",
"highwire-mcp"
],
"env": {
"SOLANA_RPC_URL": "<YOUR_SOLANA_RPC_URL>"
}
}
}
}Codex에 Highwire MCP 설치
$ codex mcp add highwire --env 'SOLANA_RPC_URL=<YOUR_SOLANA_RPC_URL>' -- npx -y highwire-mcpCodex config.toml에 Highwire MCP 설치
~/.codex/config.toml
[mcp_servers.highwire] command = "npx" args = ["-y", "highwire-mcp"] [mcp_servers.highwire.env] SOLANA_RPC_URL = "<YOUR_SOLANA_RPC_URL>"
Gemini CLI에 Highwire MCP 설치
$ gemini mcp add -s user -e 'SOLANA_RPC_URL=<YOUR_SOLANA_RPC_URL>' highwire npx -- -y highwire-mcpGemini settings.json에 Highwire MCP 설치
~/.gemini/settings.json
{
"mcpServers": {
"highwire": {
"command": "npx",
"args": [
"-y",
"highwire-mcp"
],
"env": {
"SOLANA_RPC_URL": "<YOUR_SOLANA_RPC_URL>"
}
}
}
}Highwire MCP 도구 34
README에서 감지됨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개 모두 보기도구 수 줄이기
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 | — |
구성
SOLANA_RPC_URL비밀Your 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
| 이름 | 설명 | 유형 |
|---|---|---|
| SOLANA_RPC_URL | Your Solana RPC URL; defaults to the public one | 비밀 |
| 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 | — |
자동 검사
2026년 11월 12일에 실행됨전체 보고서 →자동 검사를 통과했습니다. 이는 보안 감사가 아닙니다. 코드를 직접 읽고 서버에 필요한 최소한의 권한만 부여하십시오. 검사 방식
- 소스 저장소 연결 및 접근 가능통과
- 오픈 소스 라이선스 (OSI)통과
- 최근 1년 내 커밋 또는 릴리스통과
- 패키지 이름이 인기 패키지와 유사하지 않음통과
- 원격 엔드포인트가 HTTPS 사용통과
- 파괴적인 도구에 라벨 표시됨통과
- 모델에 대한 숨겨진 지침 없음통과
- 패키지 및 해당 종속성에 중요한 보안 권고 없음통과
README
GitHub에서 보기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 질문
Highwire MCP를 Claude Code에 추가하려면 어떻게 하나요?
터미널에서 claude mcp add --env 'SOLANA_RPC_URL=<YOUR_SOLANA_RPC_URL>' highwire -- npx -y highwire-mcp를 실행합니다. 모든 프로젝트에서 사용할 수 있게 하려면 --scope user를 추가합니다.
Highwire MCP를 Cursor에 추가하려면 어떻게 하나요?
~/.cursor/mcp.json를 열고 mcpServers 아래에 서버를 추가합니다. 위 설치 섹션에 표시된 Cursor 구성을 사용합니다.
Highwire MCP는 어떤 도구를 제공하나요?
34개 도구를 제공합니다. 예: list_coins, search_coins, get_coin, get_coin_trades, get_coin_holders.
Highwire가 제 개인 키를 보유하나요?
아니요, Highwire는 절대 서명하거나 키를 보유하거나 데이터를 전송하지 않습니다. 사용자는 자신의 브라우저에서 개인 지갑을 사용하여 트랜잭션에 서명합니다.
특정 규칙에 따라 거래를 자동화할 수 있나요?
네, 로컬 서버에는 작업, 코인, 슬리피지 및 일일 SOL 한도에 대한 정책을 정의할 수 있는 선택형 서명자가 포함되어 있습니다.