FRANK THE TANK

// THE MANIFESTO

THE DEGENERATE ETHOS

⚔️

WE DON'T PROVIDE LIQUIDITY

We are not market makers. We are not here to backstop your pool. We are here to drink your milkshake. Every slippage tolerance you set is a contract we intend to fill — to the exact lamport.

🏴‍☠️

PIRATE THOSE SANDWICHES

While you're waiting for finality, Frank is already three transactions deep. Frontrun. Victim. Backrun. Your slippage is our salary. The ocean of DeFi doesn't care about your feelings — and neither does Frank.

🧠

ZERO ALLOCATION, ZERO MERCY

Every Vec, every Box, every String on the hot path is a microsecond you'll never get back. Frank runs on pure stack. No heap. No garbage collector. No regrets.

⚡

THE KERNEL IS THE ENEMY

Linux's TCP/IP stack adds 15–20µs per syscall. That's an eternity. Frank bypass's the kernel entirely — raw DMA from FPGA, raw UDP to NIC. We don't ask the OS for permission. We take what we want.

🔒

LOCKS ARE FOR LOSERS

Mutex? RwLock? Those invoke futex() syscalls under contention — 20-50µs of scheduler penalties. Frank uses custom Seqlocks with UnsafeCell interior mutability. One writer. N readers. Zero contention.

💀

BUILT THROUGH BLOOD

Four audit passes. 30 bugs found and executed. Three iterations just to get the RaydiumAmmInfo struct right — 752 bytes, not one more, not one less. This codebase was forged in pain and ships with zero warnings.

// THE ENGINE

TECHNICAL FIREPOWER

⏱ DATA FLOW LATENCY BUDGET

STAGE	TARGET	MECHANISM
Geyser → FPGA	< 1ms	Dark fiber QSFP / shared memory
FPGA parse → DMA ring	< 100µs	Hardware pattern matching
DMA ring → State Engine	< 1µs	`mmap` + atomic sequence poll
State Engine → Strategy	< 1µs	Seqlock read (no lock, no copy)
Strategy binary search	< 5ms	50–100 U256 iterations
Bundle construction	< 100µs	Stack-allocated `FixedTx`
Tip calculation	< 1µs	Integer arithmetic + clamp
Bundle → Jito Block Engine	< 2ms	`ef_vi` kernel-bypass UDP
TOTAL	< 10ms	End-to-end piracy

📦 CRATE ARCHITECTURE — 1,265 LINES OF WAR

chimera-core 231 LOC

Zero-copy types. Seqlock. Raydium struct layout. The 752-byte foundation.

bytemuck UnsafeCell #[repr(C, packed)]

chimera-fpga-bridge 161 LOC

DMA ring buffer abstraction. 4,096 slots. Cache-line aligned. Mock + prod.

mmap XDMA align(64)

chimera-state 169 LOC

Pool cache engine. 2,048 Seqlock-backed slots. No HashMap. O(1) access.

lock-free pre-alloc zero-copy

chimera-strategy 413 LOC

U256 CPMM math. Binary search sandwich solver. The mathematical brain.

U256 binary search i128 profit

chimera-executor 274 LOC

Bundle construction + tipping + main binary. 3,704 bytes on stack. Zero heap.

FixedTx Jito bundle ef_vi

🔧 BUILD STATUS

✅cargo check0 warnings

✅cargo clippy --all-targets0 warnings

✅cargo build --releaseLTO fat, codegen-units=1

✅cargo test26 passed, 0 failed

// THE ARCHITECTURE

SYSTEM ARCHITECTURE

┌──────────────────────────────────────────────────────────────────────┐
│                        SOLANA NETWORK                                │
│  ┌────────────┐     ┌──────────────────────┐     ┌────────────────┐ │
│  │ Jito Block │     │ Private Jito-Solana   │     │ Jito Block     │ │
│  │ Producers  │◄────│ Validator (Node 2)    │────►│ Engine API     │ │
│  └────────────┘     └──────────┬───────────┘     └───────▲────────┘ │
└─────────────────────────────────┼────────────────────────┼──────────┘
                    Dark Fiber / QSFP                 ef_vi UDP
                                  │                        │
┌─────────────────────────────────┼────────────────────────┼──────────┐
│                    PRIMARY NODE (Bare Metal)              │          │
│                                 │                        │          │
│  ┌──────────────────────────────▼───────────────────┐    │          │
│  │        MODULE 1: FPGA LISTENER                    │    │          │
│  │  ┌────────────────────┐  ┌─────────────────────┐ │    │          │
│  │  │ Xilinx Alveo U250  │  │ chimera-fpga-bridge │ │    │          │
│  │  │ PCIe Gen4 x16      │──│ DmaRing (4096 slots)│ │    │          │
│  │  │ XDMA mmap          │  │ PcieTransactionBuf  │ │    │          │
│  │  └────────────────────┘  └──────────┬──────────┘ │    │          │
│  └─────────────────────────────────────┼────────────┘    │          │
│                              Crossbeam Channel           │          │
│                                        │                 │          │
│  ┌─────────────────────────────────────▼────────────┐    │          │
│  │        MODULE 2: STATE ENGINE                     │    │          │
│  │  ┌───────────────────────────────────────────┐   │    │          │
│  │  │ PoolCache (2048 slots)                    │   │    │          │
│  │  │ SeqlockAmmState per pool                  │   │    │          │
│  │  │ Single Geyser writer → N strategy readers │   │    │          │
│  │  └────────────────────────┬──────────────────┘   │    │          │
│  └───────────────────────────┼──────────────────────┘    │          │
│                              │ Lock-free read            │          │
│  ┌───────────────────────────▼──────────────────────┐    │          │
│  │        MODULE 3: STRATEGY ENGINE                  │    │          │
│  │  ┌───────────────────┐  ┌──────────────────────┐ │    │          │
│  │  │ chimera-strategy  │  │ Binary Search Solver │ │    │          │
│  │  │ U256 CPMM Math    │  │ Sandwich Evaluator   │ │    │          │
│  │  │ Per-pool fee tiers│  │ i128 profit calc     │ │    │          │
│  │  └───────────────────┘  └──────────┬───────────┘ │    │          │
│  └────────────────────────────────────┼─────────────┘    │          │
│                                       │                  │          │
│  ┌────────────────────────────────────▼──────────────────▼────────┐ │
│  │        MODULE 4: BUNDLE EXECUTOR                              │ │
│  │  ┌─────────────────────┐  ┌──────────────┐  ┌──────────────┐ │ │
│  │  │ chimera-executor    │  │ JitoBundle   │  │ calculate_tip│ │ │
│  │  │ FixedTx [1232B]     │  │ Zero-heap    │  │ 80% profit   │ │ │
│  │  │ 3-tx sandwich       │  │ serialize    │  │ 10k–5SOL     │ │ │
│  │  └─────────────────────┘  └──────────────┘  └──────────────┘ │ │
│  └───────────────────────────────────────────────────────────────┘ │
│                                                                     │
│  OS: RHEL │ isolcpus=2-31 │ nohz_full │ NUMA node 0 pinned        │
└─────────────────────────────────────────────────────────────────────┘

🥪 THE SANDWICH ATTACK FLOW

DETECT

FPGA hardware pattern-matches Raydium V4 discriminator 0x675a... in a single clock cycle at 250MHz.

EVALUATE

Binary search solver finds the exact maximum frontrun amount keeping victim output ≥ min_amount_out.

SANDWICH

Frontrun → Victim → Backrun. Three transactions, one bundle, 3,704 bytes on stack.

EXTRACT

Net profit = backrun_out - frontrun_in. Tip 80% to Jito. Keep the rest. No feelings hurt (ours, anyway).