Blazed.sh on BLAZED.sh Blog

FOCIL and MEV: Inclusion Is Not Transaction Ordering

Tue, 15 Sep 2026 08:00:00 +0000

A transaction can be included in a block and still be useless to your bot. A competing liquidation can execute first. A swap can move the pool price before your arbitrage runs. Your own transaction can appear in the block with a failed receipt and a gas bill.

That distinction matters when reading about FOCIL, short for fork-choice enforced inclusion lists. EIP-7805 proposes a way for validators to constrain which transactions builders may omit. It does not give a searcher a reservation at the top of a block, and it does not make an included transaction succeed.

Flashbots Bundle Not Included: Why a Profitable Bundle Doesn't Land

Sun, 13 Sep 2026 08:00:00 +0000

A bundle hash is an acknowledgement, not a receipt. A successful simulation is a result for a chosen state and execution environment, not a reservation in the next block. Keeping those two distinctions in your logs makes a missing bundle much easier to investigate.

The Flashbots troubleshooting guide identifies several common causes: a transaction reverts, the incentive is insufficient, a competing bundle changes the opportunity, delivery is late, or the block producer does not use the relevant builder path. More than one can apply to the same attempt.

Uniswap V4 Hooks: Dynamic Fees and Swap Simulation for Bots

Fri, 11 Sep 2026 08:00:00 +0000

Two Uniswap v4 pools can trade the same currencies and behave differently. One charges a fixed LP fee. Another uses a hook to change the fee for each swap. A third checks the caller, modifies accounting or rejects the operation under conditions your reserve calculation does not model.

For a bot, a pool’s price is therefore not enough to describe the trade. You need the pool key, hook address, execution path and state used for simulation. A successful quote through one caller does not prove the same swap succeeds through your executor.

Hegotá Explained: What the EF's EIP Tier List Tells Us About Ethereum's Next-Next Fork

Tue, 08 Sep 2026 10:00:00 +0000

Glamsterdam has not shipped yet; it is live on the Platåberget testnet and heads to Sepolia and Hoodi next, as covered in our Glamsterdam hub. But Ethereum’s fork pipeline does not wait. On September 7, 2026, the Ethereum Foundation’s Protocol Cluster published “The Hegotá EIP Opinion Post and Tier List”, the first real look at the scope of Hegotá, the fork after Glamsterdam. It grades 62 candidate EIPs using 397 individual assessments from across the Protocol Cluster, and it names exactly two of them must-ship.

Detect New Uniswap Pools on Ethereum: V2, V3 and V4 With ethers.js

Mon, 07 Sep 2026 08:00:00 +0000

A Uniswap v2 pool has its own contract address. So does a v3 pool. A v4 pool does not: it lives inside the singleton PoolManager and is identified by a PoolId.

That difference breaks a common new-pool detector. Watching newly deployed contracts can find v2 and v3 pools, but it is the wrong signal for v4. Watch the protocol’s creation or initialization events instead, and preserve the fields that identify the pool.

Why Are Pending Transactions Missing From the Mempool Feed?

Sat, 05 Sep 2026 08:00:00 +0000

Your subscription emits a transaction hash. You immediately request the transaction and get null. Or a transaction lands in a block, but its hash never appeared in your pending feed.

Those symptoms are different. The first proves that your subscription delivered a particular hash but a later lookup could not resolve it. The second only proves that you did not record a pending notification. Neither, by itself, identifies replacement, eviction or private submission.

How to Benchmark Ethereum RPC for Trading Bots

Thu, 03 Sep 2026 08:00:00 +0000

A fast response to eth_blockNumber tells you how quickly an endpoint can return a small piece of data. It does not tell you when that endpoint learned about the block, whether twenty pool reads will finish before your deadline, or whether the transaction you submit will reach a builder in time.

Our free-tier RPC comparison measured request latency, burst capacity and head delivery separately. This post is the method you can apply to your own bot. It is not a new provider ranking, and it does not reuse those measurements as if they were taken today.

An MCP Server in One Bash File

Mon, 10 Aug 2026 16:00:00 +0000

BLAZED.sh is a PaaS for latency-sensitive workloads. Users can deploy OCI containers or run JavaScript scripts without managing the servers below them.

The platform already had a REST API, and while building our CLI we also wanted an MCP server. An agent should be able to deploy something, stop it and read its logs using the same API as everyone else. Our first thought was to start another TypeScript project and install an MCP SDK. Then we realized that the Bash CLI already did nearly all of the work.

Alchemy vs Infura vs QuickNode: Free Tier RPC Latency Against a Co-located Node

Mon, 10 Aug 2026 10:00:00 +0000

Our August RPC latency benchmark measured nine keyless public endpoints and left two gaps that the post named itself: no account-backed endpoint was tested, and our own node was not in the table. This study closes both.

We registered accounts with Alchemy, Infura and QuickNode, measured their endpoints against six keyless ones, added our own production node from two separate vantage points, and added a dimension the first run missed entirely: what happens when you stop sending one request at a time and start sending the burst a strategy actually sends when a block lands.

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.

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, the public Platåberget testnet forked on August 20, and ethereum.org now puts mainnet activation in Q4 2026.

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. EIP-7732 moves the builder’s payload commitment and its payment relationship with the proposer into Ethereum’s consensus rules. The proposer can commit to a builder’s block without relying on a relay to enforce that exchange.

For searchers, the important change is timing. A consensus block and its execution payload no longer arrive as one object. The payload can arrive later, leaving less time to observe the new state, simulate a trade and reach the builder of the next block.

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).