Solana HFT Raydium Engine

High-performance liquidity pool scanner with worker-thread architecture for zero-latency detection on Solana's Raydium DEX.

🇷🇺 Russian README

---

🎯 Overview

This engine detects Raydium liquidity pool creation at the pre-liquidity stage through innerInstructions analysis, providing a 2-5 second advantage over traditional RPC-based parsers. Built for high-frequency trading strategies requiring immediate pool discovery.

---

✨ Key Features

🚀 Pre-Liquidity Detection

Identifies pools at the market creation stage by parsing innerInstructions, detecting liquidity initialization before the first byte of liquidity is added. This provides critical time advantage for MEV and front-running strategies.

⚡ Event-Driven Worker Architecture

Uses Node.js Worker Threads to offload pool analysis to separate processes. The main thread scans for pool creation events, spawns workers that subscribe to specific pool liquidity events via WebSocket, and waits for the first liquidity addition.

🔧 Low-Level Optimization

• Manual PDA Derivation: Calculates Program Derived Addresses without heavy SDK calls
• Custom Log Parsing: Bypasses standard transaction parsing for speed
• Direct RPC Integration: Minimal abstraction layer for maximum performance
• Efficient Market State Decoding: Direct buffer manipulation for Serum market data

📊 Real-Time Data Collection

Automatically collects and stores:

• Pool keys and configuration
• Token metadata (freeze authority, mutability)
• Real-time price monitoring data
• LP initialization parameters

---

🏗️ Architecture

┌─────────────────────────────────────────────────────────────┐
│                        Main Scanner                          │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ Monitors: srmqPvymJeFKQ4zGQed1GFppgkRHL9kaELCbyksJtPX │   │
│  │ (Serum DEX Program - Market Initialization)          │   │
│  └──────────────────────────────────────────────────────┘   │
│                           │                                   │
│                           ▼                                   │
│               Detects Market Creation                         │
│                           │                                   │
│                           ▼                                   │
│         Derives AMM Pool ID from Market ID                    │
│                           │                                   │
│                           ▼                                   │
│              Validates Token Properties                       │
│            (Freeze Authority, Mutability)                     │
│                           │                                   │
│                           ▼                                   │
│            ┌──────────────────────────────┐                  │
│            │   Spawns Worker Thread       │                  │
│            └──────────────────────────────┘                  │
└────────────────────────│──────────────────────────────────────┘
                         │
                         ▼
         ┌───────────────────────────────────────┐
         │        Worker Thread (Piscina)        │
         │  ┌─────────────────────────────────┐  │
         │  │ 1. Subscribe to Pool Vaults     │  │
         │  │ 2. Monitor First Liquidity Add  │  │
         │  │ 3. Collect Metadata             │  │
         │  │ 4. Track Price Movements        │  │
         │  │ 5. Export Data (CSV/JSON)       │  │
         │  └─────────────────────────────────┘  │
         └───────────────────────────────────────┘

---

📋 Prerequisites

• Node.js 20+ (Worker Threads support)
• TypeScript 5.5+
• RPC Access: Helius or Chainstack API key (free tier available)
• RAM: 4GB+ recommended for multiple concurrent workers

---

🚀 Installation & Setup

1. Clone the Repository

git clone https://github.com/yourusername/solana-hft-raydium-engine.git
cd solana-hft-raydium-engine

2. Install Dependencies

npm install

3. Configure Environment Variables

Create a .env file from the example:

cp .env.example .env

Edit .env and add your RPC API keys:

# Helius RPC API Key (Primary)
HELIUS_API_KEY=your_helius_api_key_here

# Chainstack RPC API Key (Backup)
CHAINSTACK_API_KEY=your_chainstack_api_key_here

Get API Keys:

• Helius: https://www.helius.dev/ (500k credits/month free)
• Chainstack: https://chainstack.com/ (3M requests/month free)

---

🎮 Usage

Start the Scanner

npx ts-node ScannerF/Scanner.ts

Output Structure

outScan/
└── {token_mint_address}/
    ├── key.csv          # Pool keys and configuration
    ├── meta.json        # Token metadata (name, symbol, freeze status)
    └── price_data.csv   # Real-time price monitoring data

---

🔧 Configuration

RPC Endpoints

Edit config.ts to change RPC providers or add additional endpoints:

// Example: Add QuickNode endpoint
export const url_quicknode = 'https://your-quicknode-endpoint.quiknode.pro'
export const connection_quicknode = new Connection(url_quicknode, 'confirmed')

Worker Pool Size

Adjust worker thread pool in Scanner.ts:

// Limit concurrent workers (default: unlimited)
const maxWorkers = 10;

---

📁 Project Structure

├── ScannerF/
│   ├── Scanner.ts          # Main scanner logic
│   ├── ScannerV2.ts        # Alternative scanner implementation
│   ├── getPoolId.ts        # Pool ID derivation helpers
│   └── test.ts             # Test utilities
├── mthreadings/
│   ├── analyzyWork.ts      # Main worker thread logic
│   ├── priceWorker.ts      # Price monitoring worker
│   └── analyzyWorkOrigin.ts
├── filters/
│   ├── checkMutFreez.ts    # Token metadata validation
│   ├── freeze.ts           # Freeze authority checker
│   └── mutable.ts          # Mutability checker
├── helpers/
│   ├── getOpenData.ts      # Pool initialization data parser
│   ├── monitoringPrice.ts  # Real-time price monitoring
│   └── ketToString.ts      # Key serialization utilities
├── raydium/
│   ├── raydium.ts          # Raydium SDK wrapper
│   └── getBalance.ts       # Balance queries
├── removeLiq/
│   ├── liqvCheck.ts        # Liquidity removal detection
│   └── onLogsR.ts          # Log listener for removals
├── config.ts               # RPC connection configuration
├── package.json
└── tsconfig.json

---

🧪 Technical Details

Pool Detection Methodology

1. Log Subscription: Monitors Serum DEX program (srmqPvymJeFKQ4zGQed1GFppgkRHL9kaELCbyksJtPX) for market initialization
2. Transaction Validation: Fetches and parses transaction to extract Market ID from innerInstructions
3. AMM Pool Derivation: Calculates AMM Pool ID using PDA derivation:

   seeds = [RAYDIUM_V4_PROGRAM_ID, MARKET_ID, "amm_associated_seed"]
   

4. Worker Spawn: Launches dedicated worker thread for pool monitoring
5. Liquidity Wait: Worker subscribes to vault accounts and waits for first liquidity event

Performance Characteristics

• Detection Latency: ~100-500ms from market creation
• Memory Footprint: ~150MB base + ~50MB per active worker
• RPC Calls: ~5-10 per pool detection cycle
• CPU Usage: 2-3 cores recommended for optimal performance

---

⚠️ Known Limitations

1. RPC Rate Limits: Free tier RPC providers may throttle during high-traffic periods
2. False Positives: Some market creations may not result in tradable liquidity pools
3. Network Dependencies: Requires stable, low-latency connection to Solana RPC

---

🛡️ Security Considerations

• Never commit .env file to version control
• Revoke API keys if accidentally exposed
• Use separate RPC keys for development and production
• Monitor RPC usage to avoid unexpected costs

---

📄 License

MIT License - see LICENSE file for details.

---

⚡ Built for speed. Optimized for profit. Open-sourced for the community.