Practical writing for developers building on multi-chain RPC. Tutorials, benchmarks, and honest takes on the infrastructure landscape.
Kaia is the EVM Layer 1 formed by merging Klaytn and Finschia — chain ID 8217, ~1s blocks, immediate finality, and a huge Asian user base via LINE and Kakao. It speaks standard eth_* RPC, so viem and ethers just work. Here's what carries over and the Klaytn-heritage features worth knowing.
Read →Litecoin isn't an EVM chain, so its API works differently: no eth_getBalance, no accounts, no gas. You get Litecoin Core JSON-RPC for blocks and broadcasting, plus a Blockbook REST API for address balances, UTXOs, and xpub history that Core can't provide. Here's how to use both.
Read →One stuck nonce can freeze every transaction behind it. If you're sending from a hot wallet at volume — a relayer, a market maker, a bridge — leaning on eth_getTransactionCount('pending') will eventually stall you. Here's how nonces actually work and how to manage them locally at scale.
Read →Unichain is Uniswap's own L2 — an OP Stack rollup on the Optimism Superchain, purpose-built for DeFi with ~1s blocks. It speaks standard eth_* JSON-RPC, so viem and ethers just work. Here's the chain ID, what carries over from Ethereum, and the Superchain and finality details that actually matter.
Read →Should you poll eth_getLogs on a timer or subscribe over WebSocket? Polling is simpler and more robust; WebSocket is lower-latency and lighter at scale — but drops events on reconnect. Here's the honest trade-off, when each wins, and why production systems often use both.
Read →MEV — maximal extractable value — is why your swap sometimes executes at a worse price than you saw, and why validators reorder transactions for profit. A plain-English tour of front-running, sandwiches, and back-running, how the public mempool enables it, and what you can actually do about it.
Read →Fetching every receipt in a block one transaction at a time is the N+1 problem in disguise — hundreds of round-trips per block. eth_getBlockReceipts returns all of them in a single call. Here's how it works, when to use it over JSON-RPC batching, and how to fall back when a node doesn't support it.
Read →Sei speaks standard eth_* JSON-RPC, so viem and ethers just work — but three things surprise devs coming from Ethereum: a parallelized EVM, a dual Cosmos/EVM address world with pointer contracts, and single-block instant finality that makes reorg handling unnecessary. Here's what actually differs.
Read →A transaction being mined does not mean it worked — a reverted transaction still lands in a block and still costs you gas. The receipt is where the truth lives: the status flag, the event logs, the real gas paid, and how many confirmations you should wait. Here's how to read one.
Read →Half of failed transactions are gas mistakes: an 'out of gas' revert or a fee too low to ever get mined. Here's how eth_estimateGas actually works, how EIP-1559 fees are built, why you buffer the gas limit, and how to put it all together without overpaying.
Read →zkSync Era speaks the eth_* JSON-RPC you already know — until it doesn't. Native account abstraction, a zks_ method namespace, a pubdata gas model, and non-standard deployment all trip up devs who treat it like plain Ethereum. Here's what actually differs.
Read →You send a transaction and it just says 'pending' — where does it actually go? A plain-English tour of the mempool: how transactions wait, why fees and nonces decide their fate, how to watch them, and how to unstick one.
Read →Your indexer works perfectly in testing, then a reorg silently corrupts your database with transactions that no longer exist. Here's how reorgs break indexers and two proven patterns to handle them — confirmation lag and reorg detection with rollback.
Read →Avalanche isn't one chain — it's three (X, P, C) plus a growing set of L1 subnets, and that trips up everyone wiring up 'Avalanche RPC' for the first time. Here's which endpoint you actually need, why the URLs look weird, and how to connect.
Read →If your L2 fees dropped through the floor in 2024, blobs are why. Here's what EIP-4844 blobs actually are, why they're cheap and temporary, how data availability works, and what changes for you as a developer reading the chain.
Read →If you're running your own Ethereum node, the execution client you pick decides your disk bill, your sync time, and whether historical queries are cheap or impossible. Here's an honest 2026 comparison of Geth, Erigon, and Reth — and which one fits which job.
Read →Free public RPC endpoints are perfect for learning and prototyping — and a liability in production. Here's the honest breakdown of where public RPC bites you (rate limits, downtime, deprecation, stale blocks, missing methods) and when paying for an endpoint actually earns its keep.
Read →eth_call defaults to the latest block, but you can point it at any past block to read state as it was then — a balance last Tuesday, an oracle price at a specific block. The catch: historical state reads need an archive node. Here's how to do it in viem, ethers, and web3.py, and why a full node returns 'missing trie node'.
Read →Your L2 transaction confirms in under a second — but that's not the same as final. Here's the difference between a sequencer's soft confirmation and true L1-settled finality, why optimistic and ZK rollups answer it differently, and how to check finality from RPC.
Read →Running your own node looks free next to a provider bill — until you add up the line items nobody quotes you: redundancy, engineer hours, storage growth, and the per-chain multiplier. Here's the honest all-in math, and the volume where self-hosting actually wins.
Read →A naive retry loop turns a brief blip into an outage. Here's how to retry RPC calls correctly: exponential backoff with jitter, knowing which calls are safe to retry, and failing over across providers — with copy-paste examples in viem, ethers, and web3.py.
Read →Mantle looks like a standard EVM L2 until two things trip you up: gas is paid in MNT, not ETH, and data availability runs through EigenDA instead of Ethereum calldata. Here's what that means for your RPC calls, plus the Mantle endpoints to point at.
Read →On an Ethereum L2, a single component decides the order your transaction lands in and how fast it confirms: the sequencer. Here's what it actually does, why nearly every rollup runs a centralized one today, and what that means when you're reading L2 state over RPC.
Read →Polling eth_getLogs in a loop is the slow, brittle way to watch contract events. eth_subscribe pushes logs to you over WebSocket the instant they're mined. Here's how to build a subscription that filters correctly, survives reconnects, and never silently misses an event.
Read →Solana's high block rate makes RPC rate limiting a constant production concern — 429s show up under load and break bots, indexers, and frontends. Here's why they happen, how to handle them with backoff and batching, and how to size your endpoint so they stop happening at all.
Read →dRPC and Alchemy take opposite paths to the same metered-compute billing model — one decentralized and pay-as-you-go, one a polished managed platform. Here's how they actually differ, where each wins, and why the deciding question is whether your workload fits compute-unit pricing at all.
Read →Most developers either overpay for an archive node they don't need or hit a wall on a full node that can't answer their query. The difference comes down to one thing — historical state — and here's the simple test for which one your app actually requires.
Read →Zora is an OP Stack L2 built for mints, and minting traffic is bursty in a way that punishes public RPC endpoints. Here's what you need to build on Zora in 2026 — chain ID 7777777, Superchain finality, the public-node trap, and the query patterns for reading mints at scale.
Read →A WebSocket subscription that silently drops is worse than no subscription at all — you keep running, but events vanish into the gap. Here's how to build reconnect logic that detects the drop, backs off, re-subscribes, and backfills the missed events so your indexer never loses a log.
Read →BNB Smart Chain is one of the busiest EVM chains on the planet, but its public RPC endpoints fold under any real load. Here's what you need to connect reliably in 2026 — chain ID, finality, the public-node trap, and the query patterns that matter at BSC's transaction volume.
Read →Every RPC provider limits you, but they don't agree on what a limit even is. One caps requests per second, another meters compute units, a third deducts API credits. Here's how the three models work, why the same workload costs differently on each, and how to estimate your own number.
Read →They share a name and a parent company, but Polygon PoS and Polygon zkEVM are two separate chains — different chain IDs, different gas tokens, different security models, and very different liquidity. Here's how to tell which RPC endpoint your app actually needs.
Read →Connecting to Arbitrum over WebSocket the same way you connect to Ethereum mainnet will bite you. The sequencer has no public mempool, newHeads is a firehose, and reconnecting isn't enough. Here's what actually breaks and how to handle it.
Read →Every blockchain tutorial says 'connect to an RPC endpoint' and then moves on. Here's what one actually is, what the URL means, how a request works, and when you need a provider — in five minutes.
Read →API credits look simple — until you realize different methods cost 10× each other, marketplace add-ons stack on top, and overage hits without warning. Here's the math, the gotchas, and how to actually forecast a QuickNode bill.
Read →Tracing a transaction costs 20-30× more than reading its receipt. Sometimes that's worth it; usually it isn't. Here's what trace actually tells you, the four tracer modes, and when a cheaper RPC method gets the same answer.
Read →Multicall3 lives at the same address on every EVM chain and turns 100 contract reads into one RPC call. Here's how it actually works, when to use which variant, and the gotchas that bite people in production.
Read →Three of 2025's biggest EVM chain launches, three sets of MetaMask configuration values. The exact fields to paste, why the official public RPCs aren't enough for real use, and the errors to expect when you mistype something.
Read →Eight serious providers offer Base RPC in 2026. Here's the honest comparison — pricing, free tiers, WebSocket support, archive access, and which one to pick for which workload.
Read →Your indexer works fine until it hits a single dense block range, then everything stops. Here's the cap mechanics across providers, the adaptive chunking pattern that actually works, and the code to do it right.
Read →Compute Units are documented but practically unforecastable — different RPC methods cost up to 30× each other, and a small code change can quintuple your monthly bill without any change in user count. Here's the math, with real numbers.
Read →Most Solana bots burn 80% of their RPC budget polling for state that WebSocket subscriptions would push to them for free. Here's when to use which, with the commitment-level gotchas that bite people in production.
Read →What an Ethereum archive node actually costs today — hardware, sync time, bandwidth, hosted options — and the threshold where renting one beats running it yourself.
Read →Most dApps make 50 RPC calls when they could make one. Here's how JSON-RPC batching works, why ethers.js and viem already do most of it for you, and where you still have to think about it.
Read →