Grant: solana-net-core — Open-Source Kernel-Bypass Shred Ingestion for Independent Searchers

JIP - Ideas
1

solana-net-core — Open-Source Kernel-Bypass Network Stack for Independent Searchers

Abstract

solana-net-core is a generic, low-latency Rust library designed to level the playing field for independent Jito searchers. By utilizing eBPF/XDP and AF_XDP zero-copy primitives, it achieves DPDK-level network performance on commodity dedicated servers ($300/mo) — without requiring dedicated NIC allocations or breaking LACP bonding configurations enforced by mainstream hosting providers.

This grant funds extracting production-proven HFT networking primitives into a documented, reusable public library, making sub-millisecond shred ingestion and high-speed hardware filtering accessible to the broader Solana developer ecosystem.

Motivation & Ecosystem Value Add

1. Decentralization of the Jito Searcher Ecosystem

Currently, ultra-low-latency shred ingestion from the Turbine tree is gated behind exclusive, high-capital infrastructure setups (dedicated switches, custom NIC routing, and tier-1 enterprise data centers costing $10K+/mo). Independent searchers are forced to rely on centralized, third-party managed feeds ($500–$5,000/mo), introducing latency overhead and vendor lock-in.

When only hyper-capitalized teams can compete on speed, the searcher ecosystem concentrates. This concentration reduces bundle diversity and limits price discovery efficiency on the Jito Block Engine. By lowering the infrastructure barrier to a $300/mo commodity bare-metal server, solana-net-core brings healthy competition back to the network.

2. Line-Rate Pre-Filtering for Jito Bundles

The library enables searchers to pre-filter Solana network traffic at the Network Interface Card (NIC) level using eBPF, dropping garbage data before it hits the OS kernel. This drastically optimizes downstream bundle construction pipelines and ensures cleaner, faster transaction validation via AVX-512 SIMD filters.

3. Why Jito Foundation?

The Jito Block Engine processes >90% of searcher bundles on Solana, making it the de facto standard for MEV extraction. However, the infrastructure required to ingest shreds at wire-speed remains gated behind exclusive hardware deals.

By funding solana-net-core, Jito Foundation directly:

  1. Expands searcher diversity: Independent searchers using $300/mo commodity servers can compete with hyper-capitalized teams on latency.
  2. Improves bundle quality: Line-rate pre-filtering ensures cleaner transaction validation, reducing Block Engine processing overhead.
  3. Strengthens ecosystem resilience: More searchers = healthier price discovery = better returns for validators staking with Jito.

This project is uniquely aligned with Jito’s mission: making MEV extraction accessible, efficient, and decentralized.

Integration with Jito Block Engine

The library’s output feeds directly into bundle construction pipelines that submit to Jito via:

  • gRPC SearcherService.SendBundle: Standard API for bundle submission.
  • Pre-warmed QUIC connections: Leader Lookahead module maintains persistent connections to upcoming leaders, reducing handshake latency.

The grant includes (M2) an end-to-end integration example demonstrating the full pipeline: shred ingestion → transaction parsing → bundle construction → Jito submission.

Technical Specification & Current Progress

The core primitives are already written, open-sourced, and verified on bare-metal environments (AMD Ryzen 9 9950X, Intel E810, Linux Kernel 6.14):

Already Done (Public, Verified)

  • AVX-512 Batch Filter (whitelist.rs): Verified benchmarks show first=2, mid=188, miss=320 TSC cycles for a 512-key transaction set validation. Throughput: ~0.63 cycles/key.
  • AF_XDP Zero-Copy Capture (afxdp.rs): Achieves zero-copy pipeline execution with a measured raw adapter overhead of just ~1.71 ns per packet.
  • Patched xsk-rs fork: Adds public set_addr() method for hot-path frame descriptor recycling.

Planned (Extraction from Production System, Funded by Grant)

The following modules exist in a proprietary HFT system processing live Solana mainnet traffic and will be extracted into the public library:

  • eBPF/XDP LACP Bypass (ebpf_lacp.rs, M2): Intercepts and redirects incoming packets to userspace bypass layers before the Linux kernel bonding driver acts on them, fully mitigating the standard DPDK LACP incompatibility.
  • DPDK Flow Director (flow.rs, M1): Hardware-level packet steering, tail-drop, and RX/TX queue management.
  • XDP DDoS Filter (xdp_filter.rs, M2): Driver-level junk traffic drop via eBPF filter in the ice driver.

Bare-metal Validation

The primitives are engineered specifically for Tier-1 HFT systems and have been rigorously tested against live Solana mainnet traffic (ingesting Jito ShredStream at wire-speed). The architecture completely bypasses OS kernel bottlenecks. The grant funds extracting these proven hardware-level patterns — not building from scratch.

The system architecture decouples the low-level transport layer from downstream logic, allowing the same processing pipeline to consume from either standard AF_XDP rings or high-end DPDK environments.

Implementation Plan & Milestones

The scope of work is focused on refactoring, stabilizing public APIs, ensuring multi-hardware compatibility, and delivering comprehensive integration documentation over a 12-week period.

Milestone 1 — Clean Transport API & Architectural Safety

  • Timeline: Weeks 1–4
  • Deliverables:
    • Implement the AfXdpConfig abstraction layer to clean up hardcoded kernel constants (queue_id, frame_count, etc.).
    • Refactor internal structures to completely remove bot-specific semantics (e.g., renaming AfXdpGossipFilter to a generic AfXdpCapture pipeline interface).
    • Introduce the generic PacketSink trait to eliminate static coupling with ringbuf::HeapRb.
    • Replace legacy static mut blocks with safe, modern UnsafeCell + Sync wrappers complying with Rust 2024 standards.
    • Publish system prerequisite documentation (CAP_NET_ADMIN, hugepages allocation, kernel 6.1+ constraints).
  • Funding: $3,200

Milestone 2 — Portability, Host Support Matrix & Integration Guides

  • Timeline: Weeks 5–8
  • Deliverables:
    • Implement eBPF/XDP redirect program for LACP bypass.
    • Implement auto-detection layers for bonded vs dedicated-port hardware environments.
    • Validate and publish the cross-host compatibility matrix (Hetzner, OVH, Cherry Servers).
    • Build an atomic update mechanism for validator/relay whitelist IP tracking.
    • Write an end-to-end integration sample application demonstrating a production-ready searcher shred ingestion pipeline with Jito bundle submission via gRPC SendBundle.
    • Publish the “Deploy low-latency infrastructure on a $300/mo server” master tutorial.
  • Funding: $3,300

Milestone 3 — Production DevOps & Latency Benchmarking

  • Timeline: Weeks 9–12
  • Deliverables:
    • Write a minimal-overhead eBPF telemetry module to track and monitor hardware-level packet drops.
    • Deliver reusable Ansible playbooks covering low-level Linux tuning (Hugepages setup, NUMA node pinning, isolcpus configurations).
    • Release a reproducible wire-to-userspace latency benchmark test suite.
    • Fully integrate all modules into standard docs.rs format with code coverage.
  • Funding: $3,000

Budget Breakdown

Category Cost Description
Bare-metal Testing Infrastructure $900 3 months of dedicated testing nodes equipped with Intel E810 NICs ($300/mo)
Cross-Hardware Compatibility Testing $600 Procurement of secondary hardware (Mellanox/Broadcom cards) to ensure driver resilience
Engineering & Open-Sourcing Ops $8,000 Core developer hours dedicated to decoupling proprietary logic, building the benchmark suite, writing tutorials, and structuring Ansible tools
TOTAL $9,500

Technical Risks & Mitigations

  • Risk: XDP packet redirection failures or driver discrepancies on legacy or specific NIC models.
    • Mitigation: Milestone 2 allocates funds for dedicated multi-vendor card testing (Intel, Mellanox, Broadcom). Fallback pathways will be documented.
  • Risk: eBPF program rejected by kernel verifier on older kernels (<6.1).
    • Mitigation: Require Linux 6.1+ (standard on modern dedicated servers); document clearly.
  • Risk: AVX-512 operations triggering CPU core frequency downclocking or thermal throttling.
    • Mitigation: Automation tooling in Milestone 3 will provide automated configurations for performance-oriented CPU governor setups and frequency pinning.

Worst case: if XDP redirect proves unreliable on bonded hosts for a particular vendor, we ship pure AF_XDP (still 10× faster than kernel sockets) with a “best effort” LACP bypass via RSS tuning and document the limitations transparently.

About the Developer

Independent systems/Rust engineer. Shipped (public): solana-net-core. Deep hands-on expertise in DPDK, AF_XDP, XDP/eBPF, AVX-512, kernel-bypass networking — demonstrated by the proven results above. Solo builder architecting modular infrastructure for high-performance Solana MEV.

Available for technical review calls, architecture discussion, or to provide additional benchmarking evidence on request.