BLAZED.sh Blog

Ethereum RPC Latency in 2026: IPC vs WebSocket vs Remote Providers, Measured

Sat, 01 Aug 2026 14:00:00 +0000

Every RPC provider sells latency and almost nobody publishes a distribution. You get a marketing average, occasionally a p95 on a status page, and never the methodology. We wrote a transport comparison last June that leaned on illustrative ranges because we had not measured them ourselves, and that has bothered us since. So this post measures instead: nine public Ethereum endpoints, up to 300 samples each, percentiles rather than means, a race between three subscription feeds to see who learns about a new block first, and a separate benchmark of what a JSON-RPC round-trip costs when there is no network in the path at all.

BLAZED.sh Now Has a Free Tier: 1M RPC Credits and a Live Script on the Node

Fri, 31 Jul 2026 09:00:00 +0000

Until now the only way to find out what running your code on the node actually feels like was to pay for the Beta plan or poke at the live demo panel. That was the wrong shape for a product whose whole pitch is a latency difference you have to measure yourself. So there is now a free plan: one always-on JavaScript script, running on a host with a fully synced Ethereum mainnet node, with 1,000,000 RPC credits a month. No card, no trial clock.

ERC-20 Transfer Webhooks: Build One in 50 Lines on a Co-located Node

Thu, 23 Jul 2026 07:19:00 +0000

The most requested webhook on Ethereum is also the simplest to describe: tell my backend when this token moves, or when this wallet receives funds. Exchange deposit flows, payment confirmations, treasury alerts and airdrop trackers are all variations of that one sentence. Search for an ERC-20 transfer webhook and you will mostly find hosted products that charge per delivered event, but underneath every one of them sits a primitive small enough to read in one sitting: an eth_subscribe log filter on one side and an HTTP POST on the other.

EIP-3156: The Flash Loan Standard, Explained

Wed, 22 Jul 2026 12:41:00 +0000

Flash loans are the purest expression of what makes Ethereum programmable money: you can borrow millions of dollars with no collateral and no credit check, provided you give it all back before the transaction ends. EIP-3156 is the attempt to give that primitive one standard interface, so that a borrower contract written once can take liquidity from any compliant lender. This post covers the primitive itself, the two interfaces with real Solidity, a minimal borrower, the security model behind the odd-looking magic return value, and the honest adoption picture.

Flash Loan Arbitrage: How It Works and How to Build It

Wed, 22 Jul 2026 08:33:00 +0000

Arbitrage Without Capital

In the earlier posts of this series we covered how to find arbitrage: triangular arbitrage on Uniswap for the three-pair case, and graph-based detection with Bellman-Ford for cycles of any length. Both posts quietly assumed you already hold the tokens you want to trade with. That assumption is the biggest practical barrier to arbitrage: a 0.5% spread on a 10 ETH trade pays 0.05 ETH, and scaling it means parking serious capital in hot wallets.

Arbitrage Basics: How to Build a Crypto Arbitrage Bot

Tue, 21 Jul 2026 14:26:00 +0000

Welcome Back to Arbitrage Basics

This is part three of our arbitrage series, and it is the one where the math starts running. Part one built a triangular arbitrage checker for Uniswap V2 and walked through pairs, reserves, and the exact getAmountOut formula. Part two generalized detection with graph theory: tokens become vertices, pairs become edges weighted by negative log exchange rates, and Bellman-Ford surfaces profitable cycles of any length as negative cycles. Both posts end at the same place, a function that takes fresh reserves and returns candidate trading loops.

Glamsterdam Explained: Every EIP in Ethereum's Next Upgrade

Tue, 21 Jul 2026 07:58:00 +0000

Glamsterdam is the next Ethereum hard fork after Fusaka, and it is shaping up as the most structural release the network has shipped in years. It moves the block-building auction into the protocol itself, puts a consensus-verified state diff inside every block, and reprices the corners of the EVM that stood in the way of much higher gas limits. Multi-client devnets have been running the full slate since June 2026, and mainnet activation is targeted for the second half of the year.

What Is a MEV Searcher? Infrastructure, Latency, and Whether You Need Your Own Node

Mon, 20 Jul 2026 13:47:00 +0000

If you have read anything about MEV, you have met the word “searcher”. It is the working job title of everyone actually running the bots: the arbitrageur closing a price gap between two DEX pools, the liquidator watching health factors on a lending market, the operator whose bundle landed one block ahead of yours. The term gets used constantly and defined rarely. This post fixes that. It covers what a MEV searcher actually is, where they sit in Ethereum’s block-building pipeline, which strategies they run, what their infrastructure looks like in practice, and then the question almost everyone asks next: do you need to run your own node to compete?

What Is ePBS? Ethereum's Enshrined Proposer-Builder Separation (EIP-7732), Explained

Mon, 20 Jul 2026 08:12:00 +0000

ePBS stands for enshrined proposer-builder separation. It is the change, specified in EIP-7732, that moves Ethereum’s block-building marketplace out of trusted off-chain middleware and into the protocol itself. Today, a validator who wants a professionally built block hands the deal to a relay, an unpaid third party that both sides simply have to trust. Under ePBS the builder’s signed bid goes into the beacon block directly, payment is enforced by consensus, and the relay’s trust role disappears. It ships as the headline consensus change of Glamsterdam, the hard fork after Fusaka, currently targeted at mainnet in the second half of 2026.

Infura Alternatives for High-Volume Ethereum RPC in 2026

Fri, 10 Jul 2026 10:00:00 +0000

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 July 2026 and check official docs before buying or migrating.

Alchemy Alternatives for Ethereum RPC in 2026

Fri, 10 Jul 2026 09:00:00 +0000

Alchemy is often the first serious upgrade a team makes after outgrowing a free endpoint, and it earns that position: the SDK is pleasant, the enhanced APIs remove real work, and the free tier is generous enough to carry a project a long way. The reasons people start shopping for an alternative are rarely about quality. Usually it is the compute-unit meter climbing faster than traffic, the slow realization that the enhanced APIs which saved time have also become hard to leave, or a latency-sensitive workload that would rather sit next to the node than call across the internet to reach it. This post is an honest look at the alternatives in 2026, what to weigh, and where each one actually fits. Provider plans, compute-unit weights, and enhanced-API pricing change often; treat this as a qualitative snapshot as of July 2026 and confirm against official docs before you migrate.

Cheapest Ethereum RPC in 2026: How to Actually Pay Less

Thu, 09 Jul 2026 08:00:00 +0000

Search for the cheapest Ethereum RPC and you get a list of headline prices, which is the one number that reliably fails to predict your invoice. The honest answer is that the cheapest provider depends on the shape of your traffic, and that the sticker price is only the floor. What actually decides the bill is how a model prices the heavy parts of your workload: traces, wide log queries, large responses, and bursts. This post breaks down where the real cost hides, which model is cheapest for which workload, and how to compare them without guessing. Plans and weights move often; treat the specifics here as a qualitative snapshot as of July 2026 and confirm against official docs before you commit.

Lean Ethereum: Vitalik's Third Rebuild of the Protocol, Explained

Mon, 06 Jul 2026 10:00:00 +0000

Two weeks ago, Ethereum researchers met in Berlin to keep charting the protocol’s long-term trajectory, picking up threads from the client-team discussions held in Svalbard back in April. The output is an updated strawmap, the community’s deliberately provisional sketch of where the protocol is headed, and a set of high-level takeaways that Vitalik Buterin published on July 4. The framing that ties them together is a name: Lean Ethereum.

It helps to be precise about what that name means, because it is easy to file under “another roadmap.” Lean Ethereum is not a single one-shot upgrade. It is a collection of improvements that will come online over the course of three or four years. But make no mistake: this is the third major iteration of Ethereum, in the same way that the Merge was the second. Almost every major piece of the protocol is on the table to be replaced, and the through-line is simplification, cleanup, and future-proofing, done in a way that minimizes disruption to the applications already running. Ethereum has done exactly this before with the transition from proof-of-work, so the precedent for a deep rebuild that users barely feel already exists.

Block-Level Access Lists Explained (EIP-7928)

Fri, 03 Jul 2026 10:00:00 +0000

Glamsterdam, the next Ethereum upgrade after Fusaka, has two headline changes. The consensus-layer half is ePBS, EIP-7732, which restructures how blocks get built and has absorbed most of the attention. The execution-layer half is EIP-7928, Block-Level Access Lists, and it is arguably the more practical change for anyone whose job is consuming Ethereum data rather than producing blocks. It is also further along than most people realize: Geth 1.17.4 already constructs and verifies BALs during block execution and serves them over the new eth/71 wire protocol, ahead of the fork activating anywhere public.

QuickNode Alternatives for Ethereum RPC in 2026

Wed, 01 Jul 2026 09:00:00 +0000

QuickNode is a strong product, and most teams that pick it are happy for a while. It is fast, it covers a long list of chains, and its add-on marketplace lets you switch on traces, token APIs, or a mempool feed without standing up your own infrastructure. The reasons people start shopping for an alternative are rarely about quality; they are about where the model stops fitting. Usually it is the credit meter climbing faster than traffic, an edge function bumping into its runtime ceiling, or the realization that the workload really wants to live next to the node rather than call across the internet to reach it. This post is an honest look at the alternatives in 2026, what to weigh, and where each one actually fits. Provider plans, credit weights, and add-on pricing change often; treat this as a qualitative snapshot as of July 2026 and confirm against official docs before you migrate.

Ethereum RPC Pricing Explained: Compute Units vs Credits

Wed, 24 Jun 2026 09:00:00 +0000

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.

What "missing trie node" Means and Why You Need an Archive Node

Tue, 23 Jun 2026 10:00:00 +0000

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.

Why MEV Is a Latency Game: The Case for Co-located Ethereum Nodes

Tue, 23 Jun 2026 09:00:00 +0000

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.

eth_getLogs Block Range Limits: Why Your Queries Fail and How to Fetch 1,000 Blocks at Once

Sat, 20 Jun 2026 14:30:11 +0000

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.

How to Access the Ethereum Mempool: Streaming Pending Transactions From a Co-located Node

Sat, 20 Jun 2026 14:00:00 +0000

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.

IPC vs HTTP vs WebSocket: The Fastest Way to Talk to an Ethereum Node

Wed, 17 Jun 2026 14:00:00 +0000

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.

Building Real-Time Ethereum Event Notifications with BLAZED.sh

Mon, 25 Aug 2025 14:00:00 +0000

Applications that react to blockchain events in real time need low-latency infrastructure, especially when dealing with event filters that return large datasets (liquidation monitors, DEX aggregators, cross-chain bridges).

In this tutorial, we’ll build a webhook service that monitors Ethereum events and sends notifications to configured URLs, using BLAZED.sh’s co-located Ethereum node access for a local path to chain data.

Understanding BLAZED.sh’s Architecture

BLAZED.sh is optimized for Ethereum applications that require consistent low latency and predictable costs. Instead of calling a remote gateway across the public internet, your service runs on the same host as a fully synced Ethereum node and connects today over the node’s local WebSocket endpoint (ws://eth:8545).

Unlocking the Blockchain: A Beginner's Guide to Ethereum Nodes

Mon, 21 Jul 2025 15:51:00 +0200

Ethereum runs on a network of thousands of computers called nodes. These nodes store blockchain data, validate transactions, and let external software (wallets, dApps, bots) talk to the network. If you’ve ever wondered what’s actually running behind MetaMask or your favorite DeFi app, it’s nodes, and this post explains how they work.

What Is Ethereum and Why Does It Matter?

Ethereum is a decentralized platform for running smart contracts, programs that execute automatically based on coded rules, and decentralized applications (dApps) built on top of them. DeFi, NFTs, and most of the interesting stuff in crypto runs on Ethereum.

Arbitrage Basics: Graph Theory for Multi-Pair Arbitrage Detection

Sun, 22 Jun 2025 10:00:00 +0000

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.

Arbitrage Basics: Triangular Arbitrage on Uniswap (With JS Examples)

Sat, 31 May 2025 10:00:00 +0000

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.