Infrastructure

Ethereum RPC pricing is harder to compare than it looks. Two providers can advertise similar headline numbers and still bill you wildly differently, because the unit being counted is not the same. This post breaks down the pricing models you will actually meet, shows how to estimate a monthly bill for each, and explains where a bundled-credit plan fits. Provider plans and weights change frequently; treat the numbers here as a qualitative snapshot as of June 2026 and confirm against official docs before you commit.

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.

Most write-ups about MEV focus on strategy: arbitrage, liquidations, sandwiching, backruns. Strategy is necessary, but it is not what separates a profitable searcher from a spectator. The deciding factor is usually time. By the time a pending transaction reaches you over a public RPC gateway, has been parsed, evaluated, and answered with a fresh state read across the network, the opportunity may already belong to someone closer to the chain. This post is about where those milliseconds go and how co-located node access closes the gap.

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.

Infura is where most teams start, and for good reason: it is reliable, well documented, and free to begin with. The trouble usually shows up later, at scale, when the same properties that made it easy start to constrain you. If you are reading this, you have probably already hit a 429 Too Many Requests, watched a compute-unit bill climb, or realized your whole app depends on a single provider. This post is an honest look at the alternatives in 2026, what to weigh when choosing one, and where each option actually fits. Provider plans, quotas, and pricing change frequently; treat this as a qualitative snapshot as of June 2026 and check official docs before buying or migrating.

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.