02
MEV Arbitrage Engine
A real-time arbitrage engine on Base and Robinhood Chain. It finds price gaps across DEX pools and closes them in one atomic transaction.
HOW IT WORKS
Reads the sequencer feed directly and keeps an in-memory liquidity graph that updates only the affected pools. Worker threads search for profitable cycles in parallel. Arbitrage opportunities are executed through a gas-optimized flash-loan Solidity contract, with pre-trade simulation to avoid paying gas costs for missed opportunities.
The problem
I wanted to understand how liquidity pools really work, and how arbitrage between them happens in practice. The best way to learn was to build an engine and run it on live markets. Because every trade is funded by a flash loan and repaid in the same transaction, it needed no starting capital. It started as a learning project and ended up profitable.
Architecture
Base and Robinhood Chain have no public mempool, so there is no way to see a trade before it happens. The sequencer orders transactions and streams them out as it goes. The engine reads that stream directly instead of waiting for an RPC node to serve the next block, so it reacts to each trade as early as possible and places its arbitrage in the next block. An in-memory liquidity graph mirrors every tracked pool and only recomputes the pools a transaction touches. Worker threads search that graph for profitable cycles in parallel, and the full path from market event to trade decision takes under 10 ms. Trades go through a gas-optimized Solidity contract that uses flash loans, so no capital sits idle. Every trade is simulated first, so missed opportunities do not cost gas.
Hard parts
Speed only matters until everyone is fast. Simple arbitrage on Base and Robinhood Chain became a latency race, and the winners run nodes right next to the sequencer. I could not host one there, so I moved the sequencer stream decoding to a VPS close by and only decoded what the engine needed. When that was not enough, I changed the game instead of the hardware. I focused on Uniswap v4 hooks with custom or malicious logic. Those pools misprice in ways that most bots cannot model. Winning there took careful decoding of the hook logic, not a faster connection.
Outcome
The engine executed 200+ arbitrages and made a low four-figure profit. It is no longer running: the market is saturated, and v4 hook mispricings have mostly been closed. The real result is the knowledge. I know how DEX pricing, MEV, and L2 sequencers work at the byte level, and I bring that to every trading system I build.
DEX Trading Bot
A trading bot that watches on-chain data in real time and enters trades when a strategy finds a setup. It went from idea to live execution in about two weeks.
HOW IT WORKS
A real-time data pipeline reads sequencer streams and block event logs. An entry detection system checks each incoming event against a set of trading strategies. When a strategy matches, the bot executes the trade on-chain.
The problem
I was building RWA trading on Robinhood Chain and wrote an indexer to understand its pools. The data showed a clear pattern: new token launches with the right volume and wallet activity offered good early entries. The window would not stay open for long, so speed to market mattered more than polish. I went from idea to live trades in about two weeks.
Architecture
A real-time pipeline reads the sequencer stream and block event logs, about 7 MB/s of raw on-chain data. Each event goes through an entry detection system that combines launch signals with volume and wallet metrics. When a strategy triggers, the bot builds the trade and sends it on-chain through the Uniswap Universal Router. The bot started inside the indexer and I later split it into its own service, so each part can scale and fail on its own.
Hard parts
Most signals are noise. The bot had to tell real launches from false signals and rug pulls, often within seconds of a pool being created. Entry and exit timing decided whether a good signal made money or lost it. Most of the two weeks went into tuning the strategies against live data until the hit rate was good enough to trade.
Outcome
The bot ran live for about two weeks and returned 1.2x. It is no longer running. Volume on Robinhood Chain has dropped, and the same signals no longer turn a profit. The project shows how I work when a client needs results fast: find the edge in the data, ship it, and measure it with real money.