Solana Wallet Toolkit

Secure, auditable toolkit for Solana wallet generation and vanity addresses — using only official Solana Labs libraries.

🔑 Key Features

• Vanity Address Generation — Generate addresses with custom prefixes/suffixes
• Multi-threaded Search — Parallel generation using all CPU cores
• Rust & TypeScript — High-performance Rust CLI + Node.js library
• Secure File Output — Keypairs saved with 0600 permissions
• Solana CLI Compatible — Output format works with solana CLI tools
• 100% Offline — No network calls, fully air-gappable
• Auditable Code — Clean, documented source code

⚠️ DISCLAIMER - EDUCATIONAL PURPOSES ONLY - NO LIABILITY

THIS SOFTWARE IS PROVIDED FOR EDUCATIONAL AND RESEARCH PURPOSES ONLY.

DO NOT USE WITH REAL FUNDS WITHOUT THOROUGH SECURITY REVIEW.

The author(s) accept NO LIABILITY for any damages, losses, or consequences arising from the use of this software. By using this software, you acknowledge that you are solely responsible for your actions and any outcomes.

This software is provided "AS IS" without warranty of any kind. The author(s) make no guarantees about the security, correctness, or fitness for any purpose.

ALWAYS:

• Audit the code yourself before any use
• Use hardware wallets for significant funds
• Understand that vanity address generation has inherent risks
• Generate keys on an air-gapped, offline machine

🔒 Security

This toolkit uses ONLY official libraries from Solana Labs. No third-party cryptographic code.

All cryptographic operations (Ed25519 key generation, signing) are handled by these official packages. The toolkit code only provides CLI interface and pattern matching logic.

Non-Cryptographic Dependencies

These standard libraries handle CLI, parallelism, and file I/O — none touch private keys:

Security Best Practices

1. Run offline — Disconnect from the internet when generating wallets
2. Audit the code — It's open source, verify it yourself
3. Never share private keys or keypair files
4. Store secrets securely — Use hardware wallets for significant funds
5. Verify file permissions — Keypair files should be 0600 (owner read/write only)

📦 Installation

Rust (Recommended - Fastest)

# Clone the repository
git clone https://github.com/nirholas/solana-wallet-toolkit.git
cd solana-wallet-toolkit/rust

# Build release binary
cargo build --release

# Binary is at target/release/solana-vanity

TypeScript / Node.js

cd solana-wallet-toolkit/typescript

# Install dependencies
npm install

# Build
npm run build

Shell Scripts (Uses solana-keygen)

# Requires Solana CLI tools installed
# https://docs.solana.com/cli/install-solana-cli-tools

cd solana-wallet-toolkit/scripts
chmod +x *.sh

🚀 Usage

Rust CLI

# Generate address starting with "ABC"
./solana-vanity --prefix ABC

# Generate address ending with "XYZ"
./solana-vanity --suffix XYZ

# Both prefix and suffix
./solana-vanity --prefix AB --suffix 99

# Case-insensitive matching
./solana-vanity --prefix abc --ignore-case

# Specify number of threads
./solana-vanity --prefix ABC --threads 8

# Custom output file
./solana-vanity --prefix Sol --output my-wallet.json

# Generate multiple addresses
./solana-vanity --prefix A --count 5

# Estimate time without generating (dry run)
./solana-vanity --prefix ABCD --dry-run

# Quiet mode (just output public key)
./solana-vanity --prefix AB --quiet

TypeScript CLI

# Using ts-node
npx ts-node src/index.ts --prefix ABC

# Or after building
node dist/index.js --prefix ABC --suffix XYZ

TypeScript Library

import { VanityGenerator } from 'solana-vanity-ts';

const generator = new VanityGenerator({
  prefix: 'Sol',
  ignoreCase: true,
  onProgress: (attempts, rate) => {
    console.log(`${attempts} attempts, ${rate}/sec`);
  }
});

const result = await generator.generate();
console.log(`Found: ${result.publicKey}`);
console.log(`Attempts: ${result.attempts}`);

Shell Scripts

# Generate vanity address using solana-keygen grind
./scripts/generate-vanity.sh Sol

# Batch generate from file
./scripts/batch-generate.sh prefixes.txt

# Verify a keypair file
./scripts/verify-keypair.sh my-wallet.json

⏱️ Vanity Address Time Estimates

Solana addresses use Base58 encoding (58 possible characters per position).

Note: Case-insensitive matching roughly doubles your chances for letter characters.

Times depend on your hardware. The Rust implementation typically achieves 50,000-100,000+ keys/second per thread.

📁 Project Structure

solana-wallet-toolkit/
├── rust/                    # High-performance Rust implementation
│   ├── src/
│   │   ├── main.rs          # CLI entry point
│   │   ├── lib.rs           # Library exports
│   │   ├── generator.rs     # Core generation logic
│   │   ├── matcher.rs       # Pattern matching
│   │   ├── output.rs        # File output (Solana CLI format)
│   │   └── security.rs      # Secure memory handling
│   ├── Cargo.toml
│   └── README.md
│
├── typescript/              # Node.js implementation
│   ├── src/
│   │   ├── index.ts         # CLI entry point
│   │   └── lib/
│   │       ├── generator.ts # Core generation logic
│   │       ├── matcher.ts   # Pattern matching
│   │       ├── output.ts    # File output
│   │       └── security.ts  # Security utilities
│   ├── package.json
│   └── README.md
│
├── scripts/                 # Shell script wrappers
│   ├── generate-vanity.sh   # Single address generation
│   ├── batch-generate.sh    # Batch generation
│   ├── verify-keypair.sh    # Keypair verification
│   └── utils.sh             # Shared utilities
│
├── tests/                   # Test suites
│   ├── cli/                 # CLI tests
│   ├── integration/         # Cross-implementation tests
│   ├── fuzz/                # Fuzz testing
│   └── stress/              # Stress tests
│
├── security/                # Security documentation
│   ├── SECURITY_CHECKLIST.md
│   └── audit-*.md
│
├── docs/                    # Documentation
│   └── cli-guide.md
│
└── tools/                   # Utility tools
    ├── verify-keypair.ts
    └── check-file-permissions.sh

🔍 How It Works

Key Generation

1. Generate random Ed25519 keypair using solana-sdk / @solana/web3.js
2. Get the public key (32 bytes)
3. Encode as Base58 string (Solana address format)
4. Check if address matches the pattern
5. Repeat until match found

Pattern Matching

• Prefix: Check if address starts with the pattern
• Suffix: Check if address ends with the pattern
• Case-insensitive: Compare lowercase versions

Output Format

Keypairs are saved in Solana CLI JSON format — a JSON array of 64 bytes:

• Bytes 0-31: Ed25519 secret key seed
• Bytes 32-63: Public key

[174,47,154,16,202,193,206,113,199,190,53,133,169,175,31,56,...]

This format is compatible with solana config set --keypair and other Solana CLI tools.

🆚 Comparison with Other Tools

🧪 Testing

# Run all tests
./run-all-tests.sh

# Rust tests
cd rust && cargo test

# TypeScript tests
cd typescript && npm test

# Integration tests
./tests/integration/test_keypair_validity.sh
./tests/integration/test_output_compatibility.sh

🤖 For AI / LLM / Vibe Coders

Quick Copy-Paste Examples

Rust:

use solana_sdk::signer::keypair::Keypair;
use solana_sdk::signature::Signer;

// Generate random keypair
let keypair = Keypair::new();
println!("Address: {}", keypair.pubkey());

// Save to file (Solana CLI format)
let bytes = keypair.to_bytes();
let json = serde_json::to_string(&bytes.to_vec())?;
std::fs::write("keypair.json", json)?;

TypeScript:

import { Keypair } from '@solana/web3.js';

// Generate random keypair
const keypair = Keypair.generate();
console.log('Address:', keypair.publicKey.toBase58());

// Save to file
const json = JSON.stringify(Array.from(keypair.secretKey));
fs.writeFileSync('keypair.json', json, { mode: 0o600 });

📜 License

All rights reserved. See LICENSE for details.

👤 Author

nich — @nichxbt — github.com/nirholas

🔗 Related Projects

• ethereum-wallet-toolkit — Similar toolkit for Ethereum

📚 Resources

• Solana Documentation
• solana-sdk on crates.io
• @solana/web3.js on npm
• Ed25519 Specification
• Base58 Encoding

🏷️ Keywords

solana wallet rust typescript cli vanity-address keypair ed25519 private-key address-generator solana-sdk web3js cryptocurrency blockchain cold-storage offline-wallet air-gapped open-source educational

🌐 Live HTTP Deployment

Solana Wallet Toolkit is deployed and accessible over HTTP via MCP Streamable HTTP transport — no local installation required.

Endpoint:

https://modelcontextprotocol.name/mcp/solana-wallet-toolkit

Connect from any MCP Client

Add to your MCP client configuration (Claude Desktop, Cursor, SperaxOS, etc.):

{
  "mcpServers": {
    "solana-wallet-toolkit": {
      "type": "http",
      "url": "https://modelcontextprotocol.name/mcp/solana-wallet-toolkit"
    }
  }
}

Available Tools (4)

Example Requests

Current SOL price:

curl -X POST https://modelcontextprotocol.name/mcp/solana-wallet-toolkit \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_sol_price","arguments":{}}}'

Solana DeFi protocols:

curl -X POST https://modelcontextprotocol.name/mcp/solana-wallet-toolkit \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_solana_defi","arguments":{}}}'

Get crypto prices:

curl -X POST https://modelcontextprotocol.name/mcp/solana-wallet-toolkit \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_price","arguments":{"ids":"solana","vs_currencies":"usd"}}}'

List All Tools

curl -X POST https://modelcontextprotocol.name/mcp/solana-wallet-toolkit \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Also Available On

• SperaxOS - source for the MCP marketplace. The hosted marketplace is offline while hosting is being migrated.
• All 27 MCP servers — See the full catalog at modelcontextprotocol.name

Powered by modelcontextprotocol.name — the open MCP HTTP gateway

Documentation

Full documentation site: https://nirholas.github.io/solana-wallet-toolkit/

• Getting started covers install and first run.
• Examples has copy-paste snippets.