A collection of Rust examples, SDKs, and tools for building high-performance Solana trading bots. Includes trading examples, SDKs for DEX integration, transaction parsing, key management, and real-time streaming.

中文 | English | Website | Telegram | Discord

☕ Support This Project

This SDK is completely free and open source. However, maintaining and continuously updating it requires significant AI computing resources and token consumption. If this SDK helps with your development, consider making a monthly SOL donation — any amount is appreciated and helps keep this project alive!

Donation Wallet: 6oW7AXz1yRb57pYSxysuXnMs2aR1ha5rzGzReZ1MjPV8

• ✨ Features
• 📁 Project Structure
• 🛠️ Examples
• 📎 Example README index
• 📦 SDKs & Tools
• 📋 Before you run & privacy
• 🚀 Quick Start
• 📄 License
• 💬 Contact

fnzero-examples is a hands-on example collection for building Solana trading bots with the FnZero SDK ecosystem. It focuses on runnable Rust examples for PumpFun bonding-curve trading, PumpSwap AMM trading, encrypted keystore flows, Yellowstone gRPC monitoring, ShredStream monitoring, SWQoS submit lanes, and durable nonce setup.

• Trading Examples: Ready-to-use bots for PumpSwap (outer pool) and PumpFun (bonding curve) with automated buy/sell
• Multiple SWQoS Support: Concurrent transaction submission via multiple MEV protection services
• Comprehensive SDKs: Modular SDKs for trading, parsing, key management, and streaming
• Real-time Streaming: gRPC-based transaction streaming and parsing with low-latency event processing
• Secure Key Management: Encrypted keystore support with password protection
• Production Oriented: Optimized builds and core workflows; examples still require application-specific risk controls, state management, and monitoring

fnzero-examples/
├── pumpswap_trade/              # PumpSwap (outer pool) trading example (direct private key)
├── pumpswap_trade_with_safekey/ # PumpSwap (outer pool) trading example (encrypted keystore)
├── pumpfun_trade/               # PumpFun (bonding curve) trading example (direct private key)
├── pumpfun_trade_with_safekey/  # PumpFun (bonding curve) trading example (encrypted keystore)
├── pumpfun_grpc_sniper/         # PumpFun gRPC sniper example (direct private key)
└── pumpfun_shredstream_sniper/  # PumpFun ShredStream sniper example (direct private key)

sol-safekey is resolved from crates.io by the encrypted-keystore examples; no sibling checkout is required. Local SDK checkouts remain ignored by .gitignore for optional development work.

Safekey compatibility: both *_with_safekey crates use sol-safekey 0.1.8, sol-trade-sdk 4.0.22, and the same high-level Simple*Params trade API as the direct-key examples. Cargo downloads the library automatically.

See the low-latency bot development guide for architecture, trade intents, state freshness, SWQoS, and bounded requoting.

• ✅ Flow: Buy → wait ~30s → sell; 1 round by default (change ROUNDS / REST_SECS in each crate’s src/run.rs)
• ✅ Multi-SWQoS: Concurrent submission to several MEV channels
• ✅ YAML + .env: config/dev|prod/solana.yaml, trading.yaml, and env overrides
• ✅ Durable nonce: Required when 2+ SWQoS providers are enabled—set nonce_config or NONCE_ACCOUNT; empty "" placeholders in YAML are skipped so NONCE_ACCOUNT still works
• ✅ Gas / slippage: Configurable in trading.yaml
• ✅ Default: wait_tx_confirmed: false; the bot waits a fixed interval after buy before reading balance—tune for production if needed
• ⚠️ Sell size: Each round sells the wallet’s full token balance for that mint (including any balance you held before the buy)

• The repo only ships *.yaml.example and .env.example. Your local solana.yaml, trading.yaml, and .env are created from those templates and are git-ignored (see “Before you run & privacy”).
• Environment variables can override YAML. With multiple SWQoS providers, configure durable nonce or NONCE_ACCOUNT.

API Key Application: Apply for API keys through the official website: https://fnzero.dev/swqos

Note: ⚡ = QUIC (Quick UDP Internet Connections) provides lower latency compared to HTTP/gRPC. Services using QUIC (Astralane, Node1, Soyas, Speedlanding) typically offer the best transaction submission performance.

Comprehensive Rust SDK for Solana DEX trading with unified interface for multiple protocols.

Features:

• Support for PumpFun, PumpSwap, Bonk, Raydium CPMM, Raydium AMM V4, Meteora DAMM V2
• Multiple MEV protection services (Jito, BlockRazor, Astralane, etc.)
• Middleware system for custom instruction modification
• Shared infrastructure for multi-wallet scenarios
• Address Lookup Table (ALT) support
• Durable Nonce management
• Gas fee strategy optimization

Repository: 0xfnzero/sol-trade-sdk

Transaction parsing SDK with gRPC streaming support for real-time event processing.

Features:

• Parse PumpFun, PumpSwap, Raydium, and other DEX transactions
• gRPC-based streaming for low-latency event processing
• Event filtering and transformation
• Trade event extraction
• Account filler for optimized account lookups

Repository: 0xfnzero/sol-parser-sdk

Encrypted key management library for secure Solana keypair storage.

Features:

• Encrypt/decrypt Solana keypairs with password protection
• JSON-based keystore format
• Base58 private key support
• CLI tools for key management
• Integration with trading examples

Repository: 0xfnzero/sol-safekey

Utilities for Solana transaction streaming and real-time data processing.

Features:

• Shred stream subscription
• Transaction streaming
• Event processing pipeline
• Performance-optimized parsing

Repository: 0xfnzero/solana-streamer

Do this before running any trading example for the first time. This repository does not ship your private keys, SWQoS API tokens, or production RPC URLs—only *.yaml.example and .env.example templates.

git clone https://github.com/0xfnzero/fnzero-examples.git
cd fnzero-examples

cd into the example you need (pumpswap_trade, pumpfun_trade, etc.) and copy templates per environment:

cd pumpswap_trade   # or pumpfun_trade / *_with_safekey

cp .env.example .env
cp config/dev/solana.yaml.example config/dev/solana.yaml
cp config/dev/trading.yaml.example config/dev/trading.yaml
# For prod, also copy config/prod/*.example → config/prod/*.yaml

pumpfun_grpc_sniper and pumpfun_shredstream_sniper only use .env, no YAML:

cd pumpfun_grpc_sniper   # or pumpfun_shredstream_sniper
cp .env.example .env

Then edit locally (do not commit; sniper examples only need .env):

APP_ENV=dev uses config/dev/, APP_ENV=prod uses config/prod/.

The encrypted examples obtain the sol-safekey library from crates.io automatically. Install the CLI only when you need to create or manage keystore.json:

cargo install sol-safekey --version 0.1.8 --features full --locked
sol-safekey start

In the menu, choose Create encrypted key, then Import existing private key, and save it to /path/to/fnzero-examples/pumpswap_trade_with_safekey/keystore.json.

Then set keystore_path in the example’s solana.yaml (e.g. ./keystore.json).

These paths are ignored by .gitignore—do not force-add them:

• .env, .env.* (except .env.example)
• config/**/solana.yaml, config/**/trading.yaml (your local copies)
• keystore.json and any file containing private keys

Run git status before pushing. If secrets were ever committed, rotate keys and scrub history.

• Rust 1.70+ and Cargo
• Solana CLI (optional)
• A reliable Solana RPC endpoint (prefer your own or paid; public RPCs rate-limit)

Run commands inside the example crate directory (each folder is its own Cargo package; there is no repo-root workspace). If you have not completed the steps above, copy templates and edit them first.

Option 1: Private key (PumpSwap or PumpFun)

cd pumpswap_trade          # outer AMM; use cd pumpfun_trade for bonding-curve tokens

cp .env.example .env
cp config/dev/solana.yaml.example config/dev/solana.yaml
cp config/dev/trading.yaml.example config/dev/trading.yaml
# Edit .env and yaml: PRIVATE_KEY, RPC, SWQoS tokens, nonce, … (see “Before you run”)

./run.sh <TOKEN_MINT_ADDRESS>
# or: cargo run --release -- <TOKEN_MINT_ADDRESS>

Option 2: Encrypted keystore (the example library dependency is downloaded automatically; install the CLI to generate a keystore)

cargo install sol-safekey --version 0.1.8 --features full --locked
sol-safekey start

cd /path/to/fnzero-examples/pumpswap_trade_with_safekey   # or pumpfun_trade_with_safekey

cp .env.example .env
cp config/dev/solana.yaml.example config/dev/solana.yaml
cp config/dev/trading.yaml.example config/dev/trading.yaml
# Edit solana.yaml: keystore_path, SWQoS, nonce, …

./run.sh <TOKEN_MINT_ADDRESS>

When running sol-safekey start, choose Create encrypted key → Import existing private key → Save as Keystore file, then enter the target example's keystore.json path.

# Environment: dev or prod
APP_ENV=dev

# Token mint address to trade
MINT=your_token_mint_address

# Sol amount to buy (SOL)
BUY_SOL_AMOUNT=0.01

# RPC URL
SOLANA_RPC_URL=https://your-rpc-endpoint.com

# Keystore password (for encrypted key)
KEYSTORE_PASSWORD=your_password

# Durable nonce account (required for multiple SWQoS)
NONCE_ACCOUNT=your_nonce_account_address

swqos:
  region: "Frankfurt"  # or NewYork, Tokyo, etc.
  enabled_providers:
    - provider: "Astralane"
      api_token: "your_token"
      enabled: true
    - provider: "BlockRazor"
      api_token: "your_token"
      enabled: true
    # Add more providers as needed

Each example uses .cargo/config.toml so artifacts go to build-cache/release/ (not the default target/release/).

cd pumpswap_trade    # or pumpfun_trade, pumpswap_trade_with_safekey, pumpfun_trade_with_safekey

cargo build --release
./build-cache/release/pumpswap_trade_with_safekey <TOKEN_MINT_ADDRESS>

# macOS → Linux bundle (requires x86_64-unknown-linux-gnu toolchain)
./build-linux-release.sh   # produces linux-release/deploy.tar.gz

MIT License

The repository currently declares MIT licensing; consult the upstream repository metadata for the authoritative license notice.

• Official Website: https://fnzero.dev/
• Project Repository: https://github.com/0xfnzero/fnzero-examples
• Telegram Group: https://t.me/fnzero_group
• Discord Server: https://discord.gg/vuazbGkqQE

1. Security: Never commit private keys, keystores, local solana.yaml / trading.yaml, or .env; read “Before you run & privacy” before the first run
2. Testing: Thoroughly test on devnet before using on mainnet
3. Risk: Trading cryptocurrencies involves significant risk
4. Compliance: Ensure compliance with local laws and regulations
5. RPC Limits: Monitor RPC usage to avoid rate limiting
6. MEV Services: Configure API tokens properly for MEV protection services

Contributions are welcome! Please feel free to submit a Pull Request.

• Solana Documentation
• Solana Cookbook
• Rust Documentation