MEV Intent Sentinel

• 

  dashboard-overview.png

• 

  architecture-overview.png

• 

  rust-backend-logs

Inspiration When building for AI hackathons, the dominant strategy for most developers is to build what is expected: a natural language chatbot, a document summarization tool, or a basic RAG dashboard processing English text. We wanted to escape this "Red Ocean" and build something judges would not expect.

We looked at the "Dark Forest" of decentralized exchange mempools. High-frequency EVM transaction data is notoriously noisy, filled with massive amounts of repetitive bytecode padding, execution opcodes, and zero-bytes. Feeding raw transaction traces directly into Large Language Models creates severe latency bottlenecks and unsustainable API costs. We were inspired to ask: Can we use AI context compression not just for software codebases, but to prune and decode raw blockchain execution intents in real-time?

What It Does MEV Intent Sentinel is a high-performance system that plugs directly into EVM mempools (such as the Monad testnet), intercepts pending transaction hex data, strips away opcode noise using Paritok Context Compression (paritok-4b-v1), and decodes malicious intent vectors—like front-running and sandwich attacks—before they settle on-chain. It streams real-time risk telemetry, cost-deflection metrics, and token-saving analytics to a React 19 dashboard while anchoring cryptographic intent proofs on-chain via a Solidity smart contract.

How We Built It We engineered a decoupled, high-concurrency microservice architecture:

The Rust Ingestion & Engine Core: Built with Tokio and Alloy, the backend maintains a non-blocking asynchronous WebSocket connection to the EVM mempool. It batches transaction packets and calculates real-time risk scores using Deterministic Finite Automata (DFA).

The Paritok AI Layer: We integrated the paritok-4b-v1 proxy with explicit intent-based filtering to strip execution padding and isolate whale accumulation or manipulation vectors, reducing prompt footprints by over 70%.

On-Chain Attestation: Using Foundry, we authored ProofOfIntent.sol to record verified threat signatures directly on the blockchain.

The Real-Time UI: Built with React 19, Vite, Tailwind CSS, and Recharts, the frontend consumes live telemetry feeds via WebSockets to visualize risk curves and token-saving efficiency in real time.

Challenges Faced Handling Concurrency and Throughput: Ingesting high-frequency pending transaction streams in Rust required careful channel design using Tokio mpsc and broadcast channels to prevent backpressure bottlenecks during sudden network traffic spikes.

Calldata Noise Reduction: Raw EVM input data is dense and unformatted. Tuning the Paritok compression proxy prompt to reliably strip away low-level bytecode padding while preserving critical function selectors and sender values required rigorous iterative prompt engineering.

What We Learned We learned that token efficiency is just as critical in quantitative finance and Web3 infrastructure as it is in software engineering. By treating raw execution telemetry as compressible context, we proved that AI proxy layers like Paritok can dramatically lower the cost and latency barriers of running autonomous, real-time security agents in high-throughput environments.

Built With

• alloy
• axum
• compose
• css
• docker
• foundry
• monad
• node.js
• partok
• react-19
• recharts
• rust
• solidity
• tailwind
• tokio
• typescript
• vite
• websockets