Practical writing for developers building on multi-chain RPC. Tutorials, benchmarks, and honest takes on the infrastructure landscape.
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 →Moonbeam ceased operations on July 31, 2026. We watched it go dark from the infrastructure side. Chains end in three distinct ways — full shutdown, successor migration, and rebrand — and each breaks your code differently.
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 →Public endpoints, provider free tiers, keyless access — 'free RPC' covers four very different deals with very different failure modes. A field guide to the real limits, from someone who operates against all of them.
Read →Story's IP Assets, licenses, and derivative trees are ordinary contract state on an EVM chain. A hands-on guide to indexing the IP graph with eth_getLogs, eth_call, and a WebSocket.
Read →Story rebranded to the DATA Network in June 2026, migrating $IP to $DATA and pivoting to AI training data. Here's what actually changed on-chain (almost nothing) and what to update anyway.
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 →Bitcoin Core's JSON-RPC can't tell you an address's balance — it has no address index. Here's the gap, the three ways to fill it, and how to pick a Bitcoin RPC provider.
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 →Linea is a Consensys zkEVM L2 where standard eth_* just works — but gas estimation and finality have Linea-specific behavior worth knowing. A developer's guide.
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 →Ankr's free public RPC is everywhere — until production. Here's where the public endpoints stop, how Ankr's API-credit pricing works, and when flat-rate is the better fit.
Read →Robinhood Chain is a new Arbitrum Orbit L2 built for tokenized stocks and real-world assets. Here's how to connect, what stays standard EVM, and the one thing that isn't.
Read →Scroll is a bytecode-equivalent zkEVM rollup (chain ID 534352) — it targets opcode-level equality with Ethereum, so your existing contracts, audits, and tooling work with zero changes, while ZK validity proofs give ~1-hour hard finality instead of the 7-day optimistic window. Standard eth_* (viem/ethers/foundry). Here's the developer map, including how it differs from zkSync Era.
Read →L2s differ on two independent axes: how they prove state (validity/ZK proofs vs fraud proofs) and where they put data availability (on Ethereum vs off-chain). Those two choices give you rollups, validiums, and optimiums — with real differences in cost, security, and worst-case fund recovery. Here's the taxonomy, plainly, and why it matters for developers.
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 →Berachain is an EVM-identical L1 (chain ID 80094) on a Proof-of-Liquidity consensus with a tri-token model: BERA for gas, HONEY as a native stablecoin, and BGT — a governance token you earn but cannot transfer. The RPC is standard eth_* (viem/ethers/foundry work), but treating BGT like a normal ERC-20 breaks. Here's the developer map.
Read →Monad is a high-performance EVM Layer 1 (chain ID 143) that hits 10,000 TPS via parallel execution and pipelined MonadBFT consensus — while staying fully EVM bytecode-compatible, so viem/ethers/foundry work unchanged. The parallelism is under the hood and serial-equivalent, so the RPC is standard eth_*. Here's the developer map, including the two things that actually change.
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 →Sonic is the high-performance L1 successor to Fantom Opera (chain ID 146, not 250) with sub-second finality and a 90%-fees-to-developers model. It's standard EVM (viem/ethers/foundry work), but if you're migrating from Fantom the new chain ID and S token are the first things to get right. Here's the developer map.
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 →Polkadot's RPC is JSON-RPC over HTTP — but it's the Substrate namespace (system_*, chain_*, state_*), not eth_*, so viem/ethers don't connect. The relay chain runs no smart contracts, DOT has 10 decimals (not 18), and storage is SCALE-encoded, not ABI. Here's the developer map for querying Polkadot (and Kusama / Asset Hub) over Substrate RPC.
Read →Manta Pacific is an EVM OP Stack L2 (chain ID 169) that posts its data availability to Celestia instead of Ethereum — making it a validium, and making it cheap. It's standard EVM (viem/ethers/foundry work), with ETH gas and a ~7-day optimistic withdrawal window. Here's the developer map, including what modular DA changes about how you reason on security.
Read →Metis is an EVM-equivalent optimistic rollup (chain ID 1088) notable for moving from a single sequencer to a sequencer pool — reducing the single-operator risk most L2s still carry. It's standard EVM (viem/ethers/foundry work), with METIS (not ETH) as gas. Here's the developer map, including what sequencer decentralization does and doesn't change for you.
Read →Injective is a Cosmos-SDK finance L1 (injective-1) whose defining feature is a native, chain-level central-limit order book — a protocol module, not a smart contract. The RPC is CometBFT/Tendermint JSON-RPC (not eth_*), with sub-second blocks and instant single-block finality. Here's the developer map, including how you query the exchange module and place orders.
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 →Starknet is a non-EVM validity (ZK) rollup where contracts are Cairo, not Solidity. The RPC is JSON-RPC over HTTP — but it's the starknet_* namespace, not eth_*, so viem/ethers/foundry don't connect. Accounts are contracts (native AA, no EOAs), values are felts, and finality comes from STARK proofs with no challenge window. Here's the developer map, including the eth_* → starknet_* method translation.
Read →Blast is an Ethereum L2 (chain ID 81457) with native yield — bridged ETH and USDB rebase into accounts automatically, no action required. It's standard EVM (viem/ethers work), but the rebasing changes balances with no Transfer event and contracts default to Void yield mode. Here's the developer map, including how native yield reshapes indexing and contract design.
Read →Fraxtal is Frax Finance's OP Stack L2 (chain ID 252) with two twists most Superchain L2s don't have: gas is paid in FRAX, not ETH, and its Flox system pays contract developers FXTL points for the gas their users spend. It's standard EVM (viem/ethers/foundry work), with ~2s blocks and the usual ~7-day OP Stack withdrawal window. Here's the developer map.
Read →ZetaChain is an omnichain L1 (chain ID 7000) where a single Solidity contract can read and write across connected chains — including native Bitcoin, no wrapping, no centralized bridge. The ZetaEVM is standard eth_* (viem/ethers work), but it sits on a Cosmos-SDK base with a TSS validator set. Here's the developer map.
Read →Plasma is a stablecoin-focused EVM L1 (chain ID 9745) with a protocol paymaster that makes basic USDT transfers zero-fee — users don't even need the native token. It's standard EVM (viem/ethers work), with sub-second PlasmaBFT finality and Bitcoin anchoring. Here's the developer map, including how the gasless-stablecoin model changes payment flows.
Read →Astar is a Polkadot parachain that runs both EVM and WebAssembly contracts. Chain ID 592 is its EVM endpoint — standard eth_*, so viem/ethers/foundry just work — but underneath it's Substrate with Polkadot's deterministic GRANDPA finality. Here's the developer map: what the EVM RPC gives you, and what the parachain model changes.
Read →Flare is an EVM L1 (chain ID 14) where decentralized data feeds aren't a third-party add-on — they're enshrined in the protocol. FTSO gives you price feeds and FDC verifies cross-chain and Web2 data, both read via ordinary eth_call. viem/ethers just work; here's the developer map, including how the native data layers change what you build.
Read →On Ethereum, 'the RPC' is one JSON-RPC endpoint. On Cosmos chains, 'RPC' can mean three different interfaces — Tendermint/CometBFT RPC, REST (LCD), and gRPC — each on its own port, each for a different job. Here's what each one does, when to use it, and the mental shift from calling contracts to querying modules.
Read →Celo became an OP Stack L2 in March 2025 (with EigenDA), keeping chain ID 42220. It's standard EVM, so viem/ethers work — but it has a feature almost no other chain does: pay transaction fees in stablecoins like cUSD, not just the native token. Here's the developer map, including fee currencies and the L1→L2 shift.
Read →WEMIX3.0 is a Korean gaming L1 from Wemade — EVM-compatible (chain ID 1111), ~1s blocks, WEMIX gas. viem and ethers just work, but two things shape how you build: a stake-based PoA council means instant finality and no reorgs, and the traffic is game-heavy. Here's the developer map.
Read →Sui isn't EVM and it isn't Cosmos — it's a Move chain with an object-centric model, and its RPC reflects that. You don't call contracts to read balances; you query objects by owner. Here's the developer map: the sui_* API, owned vs shared objects, sub-second finality, and how to actually read state.
Read →Taiko is a based rollup — Ethereum's own validators propose its blocks, so there's no sequencer to trust or to go down. It's also a Type-1 zkEVM, so your Ethereum tooling works bit-identically. Chain ID 167000, ETH gas, ~12s blocks. Here's what 'based' and 'Type-1' actually change for a developer.
Read →Story (chain ID 1514) is an EVM L1 purpose-built for intellectual property — registration, licensing, and royalties as protocol modules. It's CometBFT under the hood, so finality is instant, and it's standard eth_* on top, so viem just works. Here's the developer map, including how to read the IP graph.
Read →Infura's Compute Unit quotas reset daily — so the failure mode isn't a surprise bill, it's your app going dark at 4pm until midnight. Here's how Infura's metering actually behaves in production, when Infura is still the right call, and what a flat-rate alternative changes.
Read →Rootstock (RSK) is an EVM sidechain merge-mined by Bitcoin — chain ID 30, RBTC gas pegged 1:1 to BTC, ~30s blocks. viem and ethers connect in one line, but two things trip up Ethereum devs: gas is denominated in Bitcoin, and addresses use an EIP-1191 checksum that standard tooling gets 'wrong'. Here's the map.
Read →Osmosis is the leading Cosmos DEX — a non-EVM Cosmos SDK chain (osmosis-1) on CometBFT. The twist for developers: the AMM isn't a smart contract you eth_call, it's a native chain module you query over Tendermint RPC, REST, or gRPC. Here's how to read pools, prices, and swaps.
Read →Celestia isn't an execution chain — it's a modular data availability layer, so its RPC works nothing like Ethereum's. No eth_*, no smart contracts. Here's what Celestia actually does, the CometBFT RPC you connect to, how blobs and data availability sampling work, and where the celestia-node API fits in.
Read →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 →