A high-performance, real-time token detection and automatic swapping bot built in Rust for Base network. The bot monitors token deployments and executes immediate swaps with minimal latency.

• Real-time Token Detection: WebSocket-based monitoring for instant detection
• Immediate Swap Execution: Sub-second swap execution upon token detection
• Historical Testing: Test detection logic on past block ranges
• Minimal Latency: Optimized for maximum speed with streamlined logging
• Base Network: Configured for Base (Chain ID 8453) with Uniswap V2
• Verification System: Optional transaction caller verification
• Multiple Modes: Production sniping and testing capabilities -Flashblock Integration Ready: Integration with Base Flashblocks would significantly improve execution speed by enabling transactions to be included in the next block with higher priority. This is not in the project. At the time the code was created, Flashblocks was unsupported.

• Rust 1.70+
• Base network RPC access (WebSocket required)
• Private key with VIRTUALS tokens
• Environment variables configured

1. Clone the repository

   git clone <repository-url>
   cd rustBot

2. Install dependencies

   cargo build

3. Configure environment variables

   cp .env.example .env
   # Edit .env with your configuration

Create a .env file with the following variables:

Security Note: Never commit your .env file or private keys to version control.

The main production bot for real-time token sniping:

Flow:

Output Example:

For testing detection logic and development:

The bot is configured to swap VIRTUALS - Detected Tokens:

• Input Token: VIRTUALS (0x0b3e328455c4059eeb9e3f84b5543f74e24e7e1b)
• Amount: 0.001 VIRTUALS per swap
• Network: Base (Chain ID 8453)
• DEX: Uniswap V2

The bot monitors for tokens deployed by specific addresses:

• Target Deployer: 0x71B8EFC8BCaD65a5D9386D07f2Dff57ab4EAf533
• Wanted Caller: 0x81F7cA6AF86D1CA6335E44A2C28bC88807491415
• Unwanted Caller: 0x03Fb99ea8d3A832729a69C3e8273533b52f30D1A # sometimes virtuals deploy token with same name from this address to prevent sniping

• Default Gas: Conservative settings for reliable execution
• Gas Limit: Auto-calculated with buffer
• Chain: Base network (low gas fees)

Test detection logic on past blocks to verify accuracy:

Test live detection without historical data:

Test just the detection logic without swapping:

The detection system uses three confidence levels:

1. Wanted : Direct match with wanted caller address
2. Unwanted : Direct match with unwanted caller address as there is a possibility of fake token launch
3. Verify : Requires transaction verification

When USE_TX_VERIFICATION=true:

1. Extract token address from log data
2. Check if deployer matches target address
3. If confidence requires verification:
   • Fetch transaction details via WebSocket
   • Verify transaction caller
   • Cache results for performance

• Wanted tokens: Immediate swap execution + stop monitoring
• Unwanted tokens: Log rejection + continue monitoring
• Verification failures: Log rejection + continue monitoring
• Network errors: Log error + continue monitoring

The bot is optimized for minimal latency:

• WebSocket connections for real-time data
• Minimal logging before swap execution
• Direct token return (no storage overhead)
• Inline callback execution for immediate swaps
• Efficient caching for transaction verification

• INFO: Normal operation, detection events, swap results
• ERROR: Swap failures, network errors, configuration issues

• Execution Time: Time from detection to swap completion
• Gas Used: Actual gas consumption
• Transaction Hash: For blockchain verification
• Explorer Links: Direct links to BaseScan

• Never commit private keys to version control
• Use environment variables for sensitive data
• Test on small amounts before production use
• Monitor gas prices and adjust accordingly

• WebSocket reliability: Use stable RPC providers
• Base network status: Monitor for congestion
• Gas price volatility: Adjust strategies as needed
• Transaction confirmation: Typical 2-4 seconds on Base

• Start with small amounts (0.001 VIRTUALS default)
• Test thoroughly with historical data first
• Monitor swap success rates and adjust gas settings
• Have emergency stop procedures ready

1. Setup environment:

   git clone <repo>
   cd rustBot
   cp .env.example .env
   # Edit .env with your keys

2. Test with historical data:

   cargo run --bin testMain 30948300 30948310

3. Start live sniping:

   cargo run

• Use Alchemy/QuickNode for better RPC performance
• Monitor Base gas tracker for optimal timing
• Consider private mempools for competitive advantage
• Adjust gas limits based on network conditions
• Use multiple RPC endpoints for redundancy

• Connection errors: Check WSS_URL and network connectivity
• Gas failures: Increase gas limit or check Base network status
• No tokens detected: Verify deployer addresses and network
• Swap failures: Check VIRTUALS balance and allowances

1. Test with historical blocks first
2. Check environment variables
3. Verify network connectivity
4. Monitor Base network status
5. Check token balances

Built with for maximum speed token sniping on Base network.