English | 中文 README
Angel Pulse is a Rust-based Solana high-frequency arbitrage bot framework built around real-time chain events, multi-DEX liquidity monitoring, graph-based route discovery, transaction generation, and relay-aware execution.
This project is for people who are no longer satisfied with single-swap examples and want to truly understand how a complete Solana arbitrage system runs in practice. By following the source code, you can trace the full path from real-time DEX events, pool-state updates, graph construction, route search, profit analysis and risk control, all the way to transaction building and relay submission.
It is built for developers, trading researchers, and advanced users who want to dig deeper into Solana HFT, MEV competition, DEX liquidity, and execution engineering. The underlying logic is exposed instead of hidden behind a black box: you can read it, run it, modify it, and keep upgrading it into your own version.
The project ships with conservative defaults for a reason: paper mode, simulate_execution = true, and dry-run enabled in the startup script. Treat it as an engineering foundation first, then move toward live trading only after you understand the full path and risks.
Angel Pulse provides the core structure of an asynchronous Solana HFT-style arbitrage system:
| Layer | What You Get |
|---|---|
| Real-time data | Yellowstone gRPC ingestion, optional ShredStream-style switch, transaction/account/block events |
| DEX parsing | Protocol-specific parsers for swap, pool, and account events |
| Market normalization | Converts heterogeneous DEX events into normalized pool updates |
| Arb graph | Maintains a live multi-DEX graph for route discovery |
| Strategy engine | Searches 2-hop and 3-hop arbitrage candidates |
| Execution layer | Builds DEX-specific instructions and versioned transactions |
| Relay layer | Jito / 0slot / bloXroute / NextBlock / Temporal client modules |
| Safety controls | Paper trading, dry-run, size limits, stale-data checks, tip-cost-aware filters |
Many beginner Solana bots stop at a single swap or simple polling. Angel Pulse is built like a practical real-trading system:
- event-driven, not low-frequency price polling
- Rust hot path for low-latency execution logic
- real-time graph construction with 2-hop / 3-hop graph path search, not hardcoded pairs
- multi-DEX route discovery instead of one-market trading
- multi-relay-aware transaction submission
- configurable risk control, dynamic tip, dynamic slippage, and route filtering
- safe defaults for new users who want to learn before going live
- hand-built routing, not Jupiter-based; the hot path does not call any RPC/API router, keeping execution faster
The value is not in claiming that it will always make money. The value is that it shows how a Solana high-frequency arbitrage system is organized from data, to strategy, to execution.
| DEX | Status | Capability |
|---|---|---|
| Raydium AMM V4 | Supported | Swap event parsing, pool/account handling, buy/sell instruction building |
| Raydium CPMM | Supported | Swap event parsing, pool-state support, buy/sell instruction building |
| PumpSwap | Supported | Buy/sell/create-pool event parsing, buy/sell instruction building |
| Meteora DAMM V2 | Supported | Swap/swap2 parsing and DAMM v2 execution path |
| Protocol | Included Capability |
|---|---|
| Pump.fun | Token creation and trade event projection |
| Bonk / Raydium LaunchLab-style events | Pool creation and trade event projection |
| Raydium CLMM | Event and account model parsing |
| Orca Whirlpool | Market data model available for future extension |
| Strategy | Status | Description |
|---|---|---|
| Cross-DEX arbitrage | Primary | Finds price differences across supported DEX pools |
| 2-hop arbitrage | Supported | Example: WSOL -> TOKEN -> WSOL |
| 3-hop triangular arbitrage | Supported | Example: WSOL -> TOKEN A -> TOKEN B / USDC / USDT -> WSOL |
| Multi-start cycles | Supported | Optional USDC / USDT start-token support |
| Paper trading | Supported | Real market data, simulated execution |
| Dry-run mode | Supported | Logs opportunities and decisions without sending transactions |
- Rust-based Solana high-frequency arbitrage framework
- Yellowstone gRPC real-time event ingestion
- Optional ShredStream-style low-latency event path
- Multi-DEX pool normalization
- Graph-based route search
- 2-hop and 3-hop arbitrage path discovery
- Token-2022 route filtering
- Stale-data checks to avoid sending outdated opportunities
- Dynamic route pruning and edge limits
- Cached blockhash hot path
- Versioned transaction building
- DEX-specific instruction builders
- Includes tip cost in profit evaluation
- Relay client abstraction
- Jito, 0slot, bloXroute, NextBlock, Temporal modules
- Paper trading and dry-run defaults
- Beginner-friendly configuration surface
- Source code suitable for learning, modification, customization, and packaging into more advanced private editions
src/
collectors/ # Real-time data collection and event projection
collectors/streamer/ # gRPC/ShredStream utilities and protocol parsers
config/ # Settings, AppContext, runtime cache
executors/ # DEX-specific instruction and transaction builders
solana/ # Solana constants, RPC helpers, market models
strategies/ # Arbitrage strategy, graph search, route evaluation
swqos/ # Relay clients and transaction submitters
types/ # Shared events, actions, pool types
utils/ # Key loading, fee metrics, slippage, helpers
This public repository is a commercial preview. It keeps the Rust project shape, configuration sample, documentation, and a small compilable entrypoint so buyers can inspect the framework before purchase.
The complete runtime implementation is provided in the formal commercial source package.
src/
collectors/ # Real-time data collection and event projection
config/ # Settings, AppContext, runtime cache
executors/ # DEX-specific instruction and transaction builders
solana/ # Solana constants, RPC helpers, market models
strategies/ # Arbitrage strategy, graph search, route evaluation
swqos/ # Relay clients and transaction submitters
types/ # Shared events, actions, pool types
utils/ # Key loading, fee metrics, slippage, helpers
cargo check
cargo runThe public preview binary is intentionally minimal. It only verifies that the repository is a valid Rust package and prints the previewed source layout.
The formal source-code edition includes the complete runtime path:
- real-time collectors and DEX event parsers
- strategy graph construction and arbitrage route evaluation
- DEX-specific transaction builders
- paper trading and live execution paths
- relay clients and transaction submission logic
- runtime configuration, wallet loading, logging, and safety controls
The included config.example.toml shows the configuration surface used by the
formal edition.
| Config | Description |
|---|---|
[rpcs.angel_pulse_rpc].uri |
Solana RPC endpoint |
[geysers.angel_pulse_grpc].uri |
Yellowstone gRPC endpoint |
[geysers.angel_pulse_grpc].x_key |
Provider x-key, if required |
[strategies.arbitrager.arbitrage].private_key |
Optional base58 private key, empty by default |
SOLANA_KEYPAIR_PATH |
Wallet file path, defaults to ~/.solana/wallet.json in start.sh |
[executor] relay switches |
Enable only after credentials are configured |
Angel Pulse is suitable for:
- developers learning Solana MEV and arbitrage infrastructure
- Rust engineers building private trading systems
- strategy researchers studying multi-DEX route discovery
- traders who want source-level visibility instead of a black-box bot
- teams that need a base framework for private Solana arb experiments
The formal commercial package is positioned as a basic source-code edition:
- complete enough to run and study the full pipeline
- clean enough to customize and extend
- focused enough for beginners to understand
- focused on arbitrage infrastructure without unrelated strategy modules
- suitable as a foundation for private advanced editions
This repository is prepared as a paid source-code package.
For source-code purchase, please contact:
- Telegram: AaronZ789
Solana trading is risky. Arbitrage opportunities can disappear before landing. Relay failures, network latency, stale state, wrong configuration, MEV competition, and insufficient liquidity can all cause losses. Use paper mode and dry-run first. You are responsible for your own trading decisions and funds.
This repository is provided for product preview and purchase evaluation only. See LICENSE.