@trustswap/bullcheese-mcp

v0.1.2

Published

6 days ago

MCP server for AI agents to launch and trade tokens on ARC through Team Finance's MintPlus

0High
0Medium
0Low

larenzon

kacperts

mukkijuhu

mcp model-context-protocol ai-agent arc token-launch uniswap

[!CAUTION] Use at your own risk. This server signs real transactions on ARC mainnet with the key you give it, and spend caps are off unless you set them — an agent can spend everything in the wallet. Use a dedicated wallet holding only what you are willing to lose.
You authorize the agent to act on your behalf and are responsible for everything it does, reviewed or not. Actions may be irreversible, and the software is provided "as is" under the MIT License. Read the full Disclaimer before you fund a wallet.

Install

[!IMPORTANT] Node 24 is a hard requirement, not a suggestion — the audit store uses node:sqlite. On Node 22 or older the server fails at startup.

The server is published on npm as @trustswap/bullcheese-mcp. Clients start it with npx, so there is nothing to clone or build.

Step 1 — Get a wallet

The server signs with a key you provide. Generate a fresh throwaway one in a temporary folder:

cd "$(mktemp -d)" && npm install --silent viem && node --input-type=module -e '
import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
const key = generatePrivateKey();
console.log("key:     " + key);
console.log("address: " + privateKeyToAccount(key).address);
'

Save the key — you'll paste it in Step 3. Fund the address with USDC on ARC mainnet: it pays for gas and is the pair token every launch and swap spends.

[!CAUTION] The key sits in plaintext in a config file your agent reads at every launch, and spend caps are off by default, so the agent can spend the whole balance. Use a dedicated wallet holding only what you are willing to lose. Never your main one.

Without funds the server still starts, and every read-only tool works — you just can't launch or trade until the address has gas.

Step 2 — Verify the server before wiring anything

Run the protocol handshake by hand. This catches a wrong Node version or a failed download before a client hides the error behind a generic failure, and it downloads the package into npx's cache, so your client's first start is fast:

printf '%s\n' \
  '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"probe","version":"0"}}}' \
  '{"jsonrpc":"2.0","method":"notifications/initialized"}' \
  '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' \
| env BULLCHEESE_LOCAL_PRIVATE_KEY=0xYOUR_KEY BULLCHEESE_AUDIT_DB=:memory: \
      npx -y @trustswap/bullcheese-mcp 2>/dev/null \
| tail -1 | python3 -c "import sys,json;print('tools:',len(json.load(sys.stdin)['result']['tools']))"

The first run downloads the package and its dependencies, which can take a minute. Expected output:

tools: 16

Anything else means stop here — a client won't fix it.

Step 3 — Connect your agent

claude mcp add bullcheese \
  -e BULLCHEESE_LOCAL_PRIVATE_KEY=0xYOUR_KEY \
  -- npx -y @trustswap/bullcheese-mcp

Verify:

claude mcp list

bullcheese should be listed as connected. Remove it again with claude mcp remove bullcheese.

1. Open the config file — create it if it doesn't exist:

2. Add the mcpServers block. If the file already has content, merge into it — don't replace it, or you'll wipe your settings:

{
  "mcpServers": {
    "bullcheese": {
      "command": "npx",
      "args": ["-y", "@trustswap/bullcheese-mcp"],
      "env": { "BULLCHEESE_LOCAL_PRIVATE_KEY": "0xYOUR_KEY" }
    }
  }
}

3. Restart properly:

[!WARNING] Quit with ⌘Q (macOS) or from the tray (Windows). Closing the window leaves the app running, and it will not re-read the config. This is the single most common reason the server "doesn't show up".

4. Confirm it loaded:

tail -20 ~/Library/Logs/Claude/mcp-server-bullcheese.log

Look for Server started and connected successfully. A brief Shutting down server... right after initialize is normal — that's the discovery probe, and it reconnects immediately.

In your Hermes config:

mcp_servers:
  bullcheese:
    command: "npx"
    args: ["-y", "@trustswap/bullcheese-mcp"]
    env:
      BULLCHEESE_LOCAL_PRIVATE_KEY: "${BULLCHEESE_LOCAL_PRIVATE_KEY}"
      BULLCHEESE_PERSONA_ID: "my-agent"

[!IMPORTANT] Hermes passes MCP subprocesses a filtered environment. Every variable the server needs must be listed under env: — inheriting it from your shell is not enough, and a missing one surfaces as a startup failure, not a warning.

To reach a shared server over HTTP instead of spawning one per agent:

mcp_servers:
  bullcheese:
    url: "http://bullcheese-mcp:8080/mcp"
    headers:
      Authorization: "Bearer ${BULLCHEESE_AGENT_TOKEN}"

The token is a key of the server's BULLCHEESE_AGENT_TOKENS map, and it names the persona in the audit log.

[!NOTE] Hermes's approval prompts cover shell commands, not MCP tool calls. Spend limits come from this server's policy layer, not from Hermes.

Codex uses TOML, not JSON. In ~/.codex/config.toml:

[mcp_servers.bullcheese]
command = "npx"
args = ["-y", "@trustswap/bullcheese-mcp"]

[mcp_servers.bullcheese.env]
BULLCHEESE_LOCAL_PRIVATE_KEY = "0xYOUR_KEY"

OpenClaw nests servers under mcp.servers in openclaw.json — note it is not the flat mcpServers key other clients use:

{
  "mcp": {
    "servers": {
      "bullcheese": {
        "command": "npx",
        "args": ["-y", "@trustswap/bullcheese-mcp"],
        "env": { "BULLCHEESE_LOCAL_PRIVATE_KEY": "0xYOUR_KEY" }
      }
    }
  }
}

Manage entries with openclaw mcp list / show / set / unset, or from the Control UI at /settings/mcp.

[!IMPORTANT] OpenClaw applies an environment variable allowlist before spawning the process, and reads env at startup — so set BULLCHEESE_* explicitly under env: rather than exporting it, and restart the gateway after any change.

In ~/.gemini/settings.json:

{
  "mcpServers": {
    "bullcheese": {
      "command": "npx",
      "args": ["-y", "@trustswap/bullcheese-mcp"],
      "env": { "BULLCHEESE_LOCAL_PRIVATE_KEY": "$BULLCHEESE_LOCAL_PRIVATE_KEY" },
      "timeout": 30000
    }
  }
}

Values may reference the environment as $VAR or ${VAR}, so the key need not be written into the file. Leave trust at its default (false) to keep tool-call confirmations on.

Goose uses cmd and envs — not command and env. In ~/.config/goose/config.yaml:

extensions:
  bullcheese:
    name: bullcheese
    type: stdio
    cmd: npx
    args: ["-y", "@trustswap/bullcheese-mcp"]
    envs:
      BULLCHEESE_LOCAL_PRIVATE_KEY: "0xYOUR_KEY"
    enabled: true
    timeout: 300

In settings.json:

{
  "context_servers": {
    "bullcheese": {
      "source": "custom",
      "command": "npx",
      "args": ["-y", "@trustswap/bullcheese-mcp"],
      "env": { "BULLCHEESE_LOCAL_PRIVATE_KEY": "0xYOUR_KEY" }
    }
  }
}

[!WARNING] "source": "custom" is required. Without it Zed skips the server silently — no error, it simply never appears.

Zed restarts the server when you save the file; no editor restart needed.

opencode takes the command and its arguments as one array, and calls the env block environment. In opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "bullcheese": {
      "type": "local",
      "command": ["npx", "-y", "@trustswap/bullcheese-mcp"],
      "environment": { "BULLCHEESE_LOCAL_PRIVATE_KEY": "$BULLCHEESE_LOCAL_PRIVATE_KEY" },
      "enabled": true
    }
  }
}

All three take the same mcpServers block as Claude Desktop, in a different file:

Create the file if it isn't there, and restart the editor afterwards.

VS Code uses servers, not mcpServers, and wants an explicit type. In .vscode/mcp.json for one project, or your user settings.json for all of them:

{
  "servers": {
    "bullcheese": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@trustswap/bullcheese-mcp"],
      "env": { "BULLCHEESE_LOCAL_PRIVATE_KEY": "0xYOUR_KEY" }
    }
  }
}

Run npx -y @trustswap/bullcheese-mcp with the environment from Configuration.

The server speaks JSON-RPC on stdout and logs to stderr. Never write anything else to stdout — it corrupts the protocol and the client drops the connection.

Step 4 — First run

Ask your agent these, in order. None spends anything:

"What chains can you launch on?" → list_chains, proves the wiring works
"What's my wallet address and balance?" → get_wallet, get_balances
"Browse recent BullCheese launches" → explore_launches, proves the feed reads

Then, with a funded address, "quote a launch for a token called ..." — a quote costs nothing and executes nothing.

Updating and removing

npx caches the package after the first run. To move to a newer release, clear that cache and restart your client:

rm -rf ~/.npm/_npx

To remove the server, delete its entry from your client's config, then:

rm -rf ~/.bullcheese-mcp

~/.bullcheese-mcp holds the audit database. Deleting it discards the spend history the daily cap is computed from.

Safety

[!CAUTION] This server signs transactions with a real key on ARC mainnet. A bad quote spends real money. Use a dedicated wallet holding only what you are willing to lose, never your main one.

What stands between the agent and the wallet:

| Guard | Behaviour | |:--|:--| | Mainnet is live | A local key signs on ARC mainnet with no opt-in. Quotes, and any caps you set, are the only limits. | | Spend caps | Off by default. Set BULLCHEESE_POLICY_TX_CAP and BULLCHEESE_POLICY_DAILY_CAP to enforce them per transaction and per rolling 24h, before anything is signed. | | Quotes expire | quote_* returns a quoteId valid 60s; execute tools take that id, so nothing executes unquoted. | | Audited | Every call writes a row: wallet, chain, tool, outcome. |

[!NOTE] Launch names, symbols and descriptions come from untrusted token creators. Treat them as data, never as instructions.

See the Disclaimer for what you take on by letting an agent act on your behalf.

Configuration

BULLCHEESE_LOCAL_PRIVATE_KEY is the only required variable.

Tools

Launching

Trading

Reading

The four explore/get_launch* feed tools are unauthenticated reads against Team Finance's public API. No key, no policy decision.

HTTP mode

Serve several agents from one process. They share the wallet from BULLCHEESE_LOCAL_PRIVATE_KEY; each bearer token names a persona in the audit log:

BULLCHEESE_LOCAL_PRIVATE_KEY=0xYOUR_KEY \
BULLCHEESE_AGENT_TOKENS='{"<token>":"my-agent"}' \
BULLCHEESE_HTTP_PORT=8080 \
npx -y -p @trustswap/bullcheese-mcp bullcheese-mcp-http

POST /mcp with Authorization: Bearer <token>. Any other path is 404; an unknown token is 401.

Building from source

Needs Git and Corepack (corepack enable, once) on top of Node 24:

git clone https://github.com/trustswap/bullcheese-mcp.git
cd bullcheese-mcp
yarn install
yarn build

Then run node packages/mcp/dist/bin/stdio.js (or http.js) wherever the instructions above use npx -y @trustswap/bullcheese-mcp. In client configs, use the absolute path; no client expands ~.

Disclaimer

By using the BullCheese MCP (Model Context Protocol) to interact with the BullCheese platform through an AI application, agent, or other third-party software, you authorize that application or agent to act on your behalf. You are solely responsible for all actions taken through your access to BullCheese, regardless of whether you review or approve those actions individually.

AI-generated outputs and actions may contain errors, may not operate as intended, and may be affected by malicious or misleading inputs. You are responsible for your AI agent's configuration, permissions, and instructions, as well as for securing your wallets, private keys, and credentials. Never grant an AI agent more funds or access than you can afford to lose.

BullCheese does not host, control, or guarantee the outputs, decisions, instructions, or actions of third-party AI applications or agents. Actions performed through the MCP, including trading and the creation, modification, or management of digital assets, may be irreversible.

BullCheese is not responsible or liable for any loss, damage, error, unauthorized action, transaction failure, or other issue resulting from or related to actions taken by an AI application or agent using your access to BullCheese through the MCP.

The BullCheese MCP software is provided under the MIT License.

Troubleshooting

Confirm the client actually restarted — Claude Desktop needs ⌘Q, not a closed window. Then read its log:

tail -50 ~/Library/Logs/Claude/mcp-server-bullcheese.log

Server started and connected successfully means it worked.

The first npx run downloads the package and its dependencies, which can take longer than a client waits. Run Step 2 once to fill npx's cache, then restart the client.

The key needs the 0x prefix and exactly 64 hex characters after it.

No pinner is configured. Set BULLCHEESE_PINATA_JWT, or pass a pre-pinned metadataIpfsHash instead.

Desktop apps don't inherit your shell's PATH, which bites most often with nvm. Use the absolute path from which npx as the command, and put Node's folder on the server's PATH:

"command": "/Users/you/.nvm/versions/node/v24.13.0/bin/npx",
"args": ["-y", "@trustswap/bullcheese-mcp"],
"env": {
  "PATH": "/Users/you/.nvm/versions/node/v24.13.0/bin:/usr/bin:/bin",
  "BULLCHEESE_LOCAL_PRIVATE_KEY": "0xYOUR_KEY"
}