Development

You ran a query against a slightly older block, and instead of an answer you got this:

missing trie node 2bca...e91f (path ) state 0x2bca...e91f is not available

Or a nearby historical-query failure such as:

header not found

missing trie node specifically means the state needed to answer your query is unavailable. header not found can also come from a bad block reference, an unsynced endpoint, or provider retention behavior, so treat it as a related symptom rather than the exact same error. This post explains what the state trie is, why a full node prunes it, exactly when you will trip missing historical state, and how to fix it; at the end we look at why an archive node, ideally one you do not have to operate, is the only real cure.

If you have ever indexed an ERC-20, backfilled a DEX, or built a liquidation monitor, you have met this error:

query returned more than 10000 results

Or one of its many cousins: Exceed maximum block range: 5000, eth_getLogs is limited to a 1024 block range, or a silent query timeout. They all mean the same thing: your eth_getLogs call asked for more than the provider is willing to return in one request. This post explains why those limits exist, lists where the common providers draw the line, and shows a chunking strategy that fetches any range reliably. At the end we look at why running your code on the node sidesteps most of the pain entirely.

Every transaction spends a moment in limbo between “broadcast” and “mined”. That waiting room is the mempool, and it is where a lot of the interesting work in Ethereum happens: a searcher spots an arbitrage before it lands, a bot front-runs a large swap, a liquidation watcher sees the transaction that will tip a position underwater. If you want to act on a transaction before it is final, you have to read the mempool.

Every Ethereum RPC call travels over a transport, and the transport you pick sets a floor on how fast that call can ever be. For a wallet showing a balance, the difference is invisible. For an arbitrage bot that reads a price and decides whether to act before the next block, it is the whole game. This post compares the three transports your node speaks, HTTP, WebSocket, and IPC, explains where their latency comes from, and gives you a benchmark you can run to see the gap on your own setup.

Welcome Back to Arbitrage Basics

In our previous post on triangular arbitrage, we covered 3-pair arbitrage. This time we’ll use graph theory to find arbitrage across any number of trading pairs.

By modeling pairs as a weighted directed graph, we can use Bellman-Ford to detect negative cycles, which correspond directly to profitable arbitrage loops.

Why Graph Theory for Arbitrage?

Traditional triangular arbitrage only checks predefined 3-token paths. But what if profitable opportunities exist across 4, 5, or even 10 different tokens? Manual enumeration becomes computationally expensive and misses complex paths.

Welcome to Arbitrage Basics

This blog post series covers the math, finance, and programming behind arbitrage trading. In this first post, we’ll walk through the basics and write a simple arbitrage script in JS. It won’t generate real profits, but understanding the fundamentals is key before building something that can.

The most basic kind of Arbitrage: Triangular Arbitrage

Triangular arbitrage exploits price discrepancies between three trading pairs to generate profits. Start with ETH, trade it for LINK, then LINK for SHIB, then SHIB back to ETH. If exchange rates are misaligned, you end up with more ETH than you started with. The profit comes from temporary price inefficiencies caused by large trades or slow arbitrage by other traders.