Comprehensive Pump.Fun Wallet Blacklist - Protect Your Snipe Bot from Rug Pulls

If you've been sniping new tokens on pump.fun, you've likely encountered the same frustrating pattern: a new token launches, you buy in block 0, and within minutes the liquidity disappears. The creator dumps, liquidity is pulled, and you're left holding worthless tokens.

This isn't random bad luck—it's a coordinated strategy by a relatively small group of wallets that repeatedly launch tokens with the sole intent of rugging traders.

The Rug Pull Problem on Pump.Fun

Pump.fun has become the go-to platform for launching meme coins on Solana, but this accessibility has a dark side. Rug pulls are not just common—they're systematic.

Our analysis of pump.fun launches reveals:

• A large share of new tokens are launched by wallets with suspicious launch patterns
• The same wallets repeatedly launch tokens at high frequency
• Average time to rug: 2-15 minutes after launch
• High-frequency launchers: Some wallets launch 1+ tokens every 5 minutes (thousands per week)

Traditional on-chain analysis is too slow. By the time you've checked a creator's history, you've already bought the token. You need an in-memory wallet check that costs next to nothing, to skip known scammers before your buy transaction is even submitted.

The Solution: AllenHark Wallet Blacklist

We've compiled a comprehensive blacklist of 7,900+ Solana wallet addresses known for high-frequency token launches on pump.fun. This list is:

• Actively maintained: Updated daily with newly identified high-frequency launchers
• Built for bots: Designed to sit inside a snipe bot's decision loop
• Constant-time lookups: Hash-based indexing, checked in memory
• Open format: Simple JSONL format compatible with any language

Download the Blacklist

Each entry includes:

{
  "addr": "3DadyvFvwkTTmAyyPnBTkuDu3CxUdDN3WxDNfwjC219L",
  "ts": 1763076072862,
  "hash": "5dc00e16480fa054"
}

• addr: Solana wallet address
• ts: Unix epoch timestamp (in ms) when added to blacklist
• hash: 8-byte hash for quick lookups

The Rust Implementation

Speed matters when sniping. A blacklist check must not slow the decision loop. Our Rust implementation keeps it in memory and constant-time using:

Key Performance Features

1. Hash-based lookups: O(1) constant-time checks using DashSet
2. Lock-free reads: Concurrent address validation without mutex contention
3. LRU caching: In-memory cache for frequently-checked addresses (a cache hit skips hashing)
4. Optimized djb2 hash: Non-cryptographic hash, cheap to compute

What Each Operation Costs

Integration Example

Here's how to integrate the blacklist into your pump.fun sniper:

use blacklist::Blacklist;

#[tokio::main]
async fn main() -> Result<()> {
    // Initialize blacklist (one-time at startup)
    let mut blacklist = Blacklist::new("./blacklist.jsonl");
    blacklist.load().await?;
    
    println!("✅ Loaded {} blacklisted wallets", blacklist.size());

    // Main snipe loop
    loop {
        // Monitor mempool for new pump.fun tokens
        let new_token = monitor_mempool().await?;
        let creator_wallet = new_token.creator;
        
        // In-memory blacklist check, O(1)
        if blacklist.has(&creator_wallet) {
            println!("⚠️  SKIP - Known rugger: {}", creator_wallet);
            continue; // Skip this token entirely
        }
        
        // Safe to proceed - creator not on blacklist
        println!("✅ Clean wallet - proceeding with snipe");
        execute_snipe(&new_token).await?;
    }
}

Full implementation available in our blacklist documentation.

Real-World Impact

What the blacklist changes in a snipe bot:

• Repeat launchers are skipped before a buy is built
• The check runs in memory, so it adds almost nothing to the decision loop
• New wallets still get through: a wallet that has never launched before is not on the list, so keep your other checks

How to Use This in Your Snipe Bot

Step 1: Download the Blacklist

Download blacklist.jsonl to your bot directory.

Step 2: Choose Your Integration

Option A - Rust (Recommended): Use our Rust implementation
Option B - TypeScript: Parse JSONL and use Set or Map for lookups
Option C - Python: Use pandas or simple JSON parsing

Step 3: Load at Startup

Load the blacklist once when your bot starts. Don't reload on every token check—that's too slow.

Step 4: Check Before Every Buy

if blacklist.has(&token_creator) {
    // Skip this token
    continue;
}

// Proceed with normal snipe logic

Step 5: Optionally Reload Periodically

If you want to pick up new blacklist entries without restarting:

// Reload every 6 hours
tokio::spawn(async move {
    loop {
        tokio::time::sleep(Duration::from_secs(6 * 3600)).await;
        if let Err(e) = blacklist.reload().await {
            eprintln!("Failed to reload blacklist: {}", e);
        }
    }
});

Advanced: Cross-Process Safety

If you're running multiple bot instances or want to add addresses from different processes, the Rust implementation includes file locking:

// Process A: Snipe bot checking addresses
let is_safe = blacklist.has(&wallet); // Read lock (shared)

// Process B: Admin adding new scammer
blacklist.add(&new_scammer).await?; // Write lock (exclusive)

The implementation uses fs2 for cross-process file locking, preventing race conditions and data corruption.

Contributing to the Blacklist

Found a wallet that's clearly rugging? You can add it to your local blacklist:

cargo run --bin add_blacklist -- --address <SCAMMER_WALLET>

We also accept submissions via our Discord server. If you can provide evidence of high-frequency launching patterns, we'll add the wallet to the public blacklist.

API Access (Coming Soon)

We're building an API for real-time blacklist updates:

• WebSocket stream: Get notified immediately when new scammers are identified
• REST API: Query wallet reputation scores
• Bulk lookups: Check multiple addresses in one request

Join the waitlist at allenhark.com

Why This Works

The key insight is that rug pull behaviors cluster around specific wallets. Most scammers:

1. Create a wallet
2. Launch 5-20 tokens over 1-2 weeks
3. Rug them all
4. Abandon the wallet (or get blacklisted)

By maintaining a list of these known-bad wallets, you can avoid the rug pulls that come from repeat launchers without complex on-chain analysis.

The rest are either:

• Brand new wallets (no history yet)
• Occasional ruggers who only do it once
• Sophisticated actors who rotate wallets frequently

For these, you still need other protections (contract analysis, liquidity locks, etc.). But the blacklist eliminates the repeat offenders.

Technical Details

Why Rust?

We chose Rust for the reference implementation because:

• Zero-cost abstractions: No GC pauses during critical snipe windows
• Memory safety: No crashes from race conditions or null pointers
• Performance: Predictable, in-memory lookups
• Concurrency: Lock-free data structures (DashSet) for multi-threaded bots

Why Hash-Based Lookups?

Solana addresses are 32-44 character base58 strings. Direct string comparison or HashMap lookups would be slow. Instead, we:

1. Hash each address to a fixed 16-character hex string (8 bytes)
2. Store hashes in a DashSet (lock-free hash table)
3. On lookup, hash the input and check set membership

This reduces lookup from O(n) string comparison to O(1) integer comparison.

File Format Rationale

We use JSONL (JSON Lines) instead of a single JSON array because:

• Append-friendly: Adding new entries doesn't require rewriting the entire file
• Streaming: Can process files larger than RAM
• Line-atomic: Each line is a complete entry (no partial-write corruption)
• Standard: Works with jq, grep, and other command-line tools

Conclusion

Rug pulls on pump.fun are a systemic problem, but they're also a solvable one. By maintaining a blacklist of known bad actors and integrating an in-memory wallet check into your snipe bot, you can skip repeat ruggers without slowing your bot down.

Download the blacklist and start protecting your trades today. For complete implementation details, see our blacklist documentation.

Blacklist last updated: September 30, 2026 (7,900+ entries)