This MCP server exhibits significant gaps in definition quality across multiple dimensions. While all 12 tools have names following the verb_noun pattern (wallet_get_balance, wallet_create_transaction, etc.), critical issues emerge in parameter descriptions, output schema documentation, and error handling guidance. Most tool descriptions are present but generic (10-30 chars), lacking WHAT/WHEN/WHY context required by LLMs. Parameter descriptions are inconsistently provided, some params (e.g., publicKey in wallet_get_balance) have zero description, while others provide minimal context. No output schemas are documented anywhere in the source. Error handling is minimal: handlers catch exceptions but return generic error messages without recovery guidance. The tool set exhibits poor composition concerning sensitive operations: wallet_sign_transaction accepts a private key as a parameter (severe security issue), and wallet_send_transaction performs an irreversible operation with no confirmation or dry-run pattern.
CRITICAL SECURITY: wallet_sign_transaction accepts private key as a parameter. Private keys must NEVER be exposed as tool parameters, they must be injected server-side via environment variables or secure vaults. Agent traces log all parameters, leaking secrets into logs and prompt history.
Missing parameter descriptions: Most parameters lack descriptions explaining what they control. E.g., publicKey in wallet_get_balance has no description; 'commitment' enum values are undocumented. LLMs cannot infer parameter meaning from names alone.
No output schemas documented. The source code provides no documentation of what fields tools return or their structure. LLMs cannot plan downstream tool calls or extract data without knowing return types.
wallet_get_balancewallet_get_token_accounts
Recommendations
URGENT: Remove privateKey parameter from wallet_sign_transaction and wallet_import_private_key. Implement server-side secret injection using environment variables or a secure vault (e.g., AWS Secrets Manager, HashiCorp Vault). The server should load the private key at startup and use it internally without exposing it as a parameter.
Add comprehensive parameter descriptions to every parameter. For each enum (commitment, network, skipPreflight), document what each value means and when to use it. For required parameters (toPublicKey, amount, signature), explain the format, constraints, and valid ranges in the description text, not just in code comments.
Document output schemas for all 12 tools. For each tool, create a structured response type showing all returned fields, their types, and meanings. E.g., wallet_get_balance should return { balance: number; publicKey: string; commitment: string }. Make these visible in the tool description or a separate schema document.
Expand tool descriptions to 100 - 200 characters. Add context: WHAT the tool does, WHEN to use it (e.g., 'Call this after opening the app to check the default wallet balance'), and any prerequisites. E.g., 'Get the SOL balance of a Solana address. Uses the configured default wallet if no publicKey provided. Returns balance in Lamports (1 SOL = 1 billion Lamports).'
Implement categorized error responses. Catch exceptions and return structured errors like: { error: 'Invalid address', category: 'user_fixable', suggestion: 'Address must be a valid base58 string. Call wallet_validate_address() first.' } This lets LLMs self-correct.
Score history
Overall score trend
↓ 7 points across a rubric change (v1 → v2)
42/100
Scored
Grade
Overall
Spec posture
Rubric
2026-09-22
F
42
2026-07-28+
v2
2026-03-09
F
49
-
v1
wallet_import_private_key
read onlysource verified52/100
Import a private key and get the corresponding public key
Generic, unhelpful descriptions (10 - 30 chars). Most tool descriptions are too short to guide LLM selection: 'Get the balance of a Solana address' (39 chars) lacks WHEN to use this vs alternatives, what prerequisites exist, or what happens when the wallet is not set. Baseline for A+ tools is 194 chars average.
Irreversible operation wallet_send_transaction lacks confirmation or dry-run pattern. Agents make mistakes, sending a transaction is irreversible and can transfer real funds. No confirmation_request or dry-run variant exists.
Error handling returns only generic messages. Handler in index.ts catches errors and returns { error: (error as Error).message }, which provides no recovery guidance. LLMs cannot determine if an error is retryable, user-fixable, or fatal.
Missing permission gates. Tools like wallet_send_transaction and wallet_switch_network perform sensitive operations but do not verify that the calling agent/user has authority to execute them.
No audit logging. The source contains no logging of tool invocations (who called what, when, with which parameters, and outcome). Agent-initiated financial transactions must be traceable for compliance and incident response.
No input validation or constraints. Parameters like 'amount' in wallet_create_transaction accept a free-form number with no minimum/maximum bounds. An agent could attempt to transfer negative amounts or astronomically large values, causing silent API failures.
Tool composition: wallet_create_transaction + wallet_sign_transaction + wallet_send_transaction requires three sequential calls where users naturally expect 'send 1 SOL to address X' in one call. Consider wrapping the common 3-step flow into a higher-level tool.
Add permission gates to sensitive operations. Before wallet_send_transaction or wallet_switch_network execute, verify the calling agent/user has 'write:wallet' or 'admin' scope. Return a clear 'Unauthorized' error if not.
Implement audit logging using stderr or OpenTelemetry. Log every tool invocation with: timestamp, tool name, input parameters (excluding private keys), caller identity, and result (success/failure). This is non-negotiable for financial operations.
Add input validation. For wallet_create_transaction, validate amount >= 0 and <= account balance. For commitment, validate it's one of the allowed enum values. Return specific error messages like 'Invalid commitment: got "invalid", expected one of: confirmed, finalized, processed'.
Add a dry-run parameter to wallet_send_transaction. E.g., { dryRun: true } should simulate the transaction without submitting it, returning estimated fees and final balance. This prevents accidental fund transfers.
Consider composing wallet_create_transaction + wallet_sign_transaction + wallet_send_transaction into a single wallet_send_sol tool that accepts { toAddress, amount } and handles signing/submission internally, unless the 3-step granularity is intentional for advanced users.
Add bounds checking to numeric parameters: amount (min 0, max account balance), page_size if pagination is added (1 - 100), days (1 - 365). Document these in parameter descriptions.
Return chaining IDs in all responses. If wallet_send_transaction returns a transaction signature, also return the source address, destination address, and timestamp so downstream tools (like wallet_check_transaction) have all necessary context without extra lookups.