27 posts.
Add protect=1 to your SwiftNodes Ethereum endpoint and your transactions skip the public mempool entirely — routed through a private relay that shields them from sandwich bots and rebates backrun value to you.
Read →A light client verifies Ethereum's headers against the validator set on your laptop — turning any untrusted RPC endpoint into a verified one. How sync committees work, what Helios-style clients actually do, and their honest limits.
Read →Every eth_call answer is just something a server told you. eth_getProof returns state with a Merkle proof you can check yourself — the primitive behind bridges, light clients, and trust-minimized reads.
Read →Since Pectra, a plain wallet address can carry code. What EIP-7702 delegation actually does, how to spot it over RPC, and why 'no code means EOA' is no longer a safe assumption.
Read →The write path trips up more developers than the read path. Here's why you sign transactions locally and broadcast them with eth_sendRawTransaction — with the full build-sign-send flow.
Read →Every time you move funds to an L2 you use a bridge — but 'bridge' hides several very different mechanisms with very different risk. A plain explainer of how they actually work.
Read →eth_call's third parameter lets you override balances, code, and storage before simulating. Here's how state overrides work, with a reproducible example and real use cases.
Read →eth_syncing returns false when a node is fully synced — and also when it hasn't started syncing. That trap, plus how to really tell if an RPC node (your own or a provider's) is at the chain tip: compare block height to a reference, check block-timestamp freshness, and the Solana equivalents (getHealth, catchup). A liveness check is not a freshness check.
Read →You can fetch logs with eth_getLogs and eth_subscribe — but the raw log is address + topics + data, not a readable event. This tutorial explains how logs are encoded (topic0 = the event signature hash, indexed params in topics, the rest in data), how to decode them in viem/ethers/web3.py, and the traps: indexed dynamic types, address padding, and anonymous events.
Read →Account abstraction lets a smart contract — not a private key — decide what makes a transaction valid, enabling gasless UX, social recovery, session keys, and batching. This explainer covers the EOA-vs-contract-account split, how ERC-4337 adds AA on top of Ethereum with UserOperations and bundlers, and how chains like zkSync and Starknet make accounts contracts natively.
Read →Reading a balance sounds trivial, but it's where indexers quietly go wrong: native vs token, wrong decimals, summing Transfer events, rebasing and fee-on-transfer tokens, and latest-vs-historical reads. Here's how to read balances correctly over RPC, with viem/ethers/web3.py examples.
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 →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 →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 →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 →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 →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 →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 →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 →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 →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 →