Scroll RPC: The zkEVM That Runs Ethereum Bytecode Unchanged

"zkEVM" covers a wide spectrum, and where a chain sits on it decides how much of your Ethereum knowledge transfers. Scroll is at the far end: it's a bytecode-equivalent zkEVM (chain ID 534352), meaning it targets opcode-level equality with the EVM. Your existing contracts deploy with no changes, the same audits still apply, the same tooling works, and the RPC is plain eth_* — while ZK validity proofs give it ~1-hour hard finality instead of an optimistic rollup's 7-day withdrawal window. If you've read our zkSync Era spotlight, Scroll is the interesting contrast: where zkSync is EVM-compatible (Solidity works, but it's a different VM under the hood), Scroll aims to be EVM-equivalent. Here's the map.

The essentials

Scroll mainnet (live since October 2023) is chain ID 534352, a ZK rollup with:

• ETH as the gas token (18 decimals) — no separate token to hold.
• ~3-second blocks — fast soft confirmation from the sequencer.
• Bytecode-equivalent zkEVM — full opcode equivalence with the EVM; existing Ethereum contracts run identically.
• ZK validity proofs — every state transition is proven and verified on Ethereum, giving hard finality in ~1 hour (no fraud-proof challenge window).
• A true rollup — transaction data is posted to Ethereum (via blobs), so data availability is Ethereum-grade (see rollup vs validium).

Connecting is completely standard EVM:

import { createPublicClient, http, defineChain } from "viem";

const scroll = defineChain({
  id: 534352,
  name: "Scroll",
  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.swiftnodes.io/rpc/scroll?key=YOUR_API_KEY"] } },
});

const client = createPublicClient({ chain: scroll, transport: http() });
await client.getBlockNumber();   // just works

The headline: "equivalent," not just "compatible"

This distinction sounds like marketing until it bites you, so it's worth being precise. A compatible EVM (like zkSync Era) runs your Solidity, but through a different compiler and VM — which means some low-level things differ (custom deploy semantics, non-standard CREATE2 behavior, its own account-abstraction model, occasional edge cases in bytecode-level tricks). An equivalent EVM like Scroll targets identical opcode behavior, so:

• Your existing bytecode runs as-is. Contracts compiled for Ethereum mainnet behave the same on Scroll — no recompilation for a different VM, no dialect.
• Your audits still count. Because the execution semantics match, a contract audited for mainnet doesn't acquire new behavior on Scroll.
• Tooling is unchanged. Foundry, Hardhat, ethers, viem, and standard debuggers work without special plugins, because there's nothing non-standard to accommodate.

The practical upshot: if you want a zkEVM where "it just works, exactly like mainnet" is the design goal, Scroll is built for that. The ZK part is invisible to your code — it's the proving system underneath, not something you interact with through the RPC.

Finality: fast, and actually final in ~1 hour

Here's where Scroll's ZK nature pays off versus the optimistic rollups we've covered (Blast, Unichain, Base):

• Soft confirmation (~3s) at the sequencer — fast, and what your users feel.
• Hard finality in ~1 hour — once the validity proof is generated and verified on Ethereum, the state is cryptographically final. There's no 7-day fraud-proof window, because there's nothing to dispute: the proof is the guarantee.

For anything moving value L2→L1 — bridges, withdrawals, cross-rollup flows — that's a big practical difference: hours, not a week. The two-tier model is still worth understanding (soft vs. hard finality): the sequencer head is fast but reorg-capable until the proof lands, so key your indexer on block hash and reconcile (handling chain reorgs). But the hard side resolves far quicker than optimistic chains.

Contrast the other ZK approaches: Starknet also uses STARK validity proofs but is non-EVM (Cairo, starknet_*), and zkSync Era is a compatible-but-not-equivalent zkEVM. Scroll's pitch is validity proofs with full EVM equivalence — ZK security, zero relearning.

What carries over unchanged (essentially everything)

Because Scroll is bytecode-equivalent, treat it as Ethereum-with-cheaper-gas:

• eth_call, eth_getBalance, eth_getLogs, eth_getTransactionReceipt, eth_estimateGas, eth_sendRawTransaction, eth_subscribe all behave normally.
• Solidity contracts, ABIs, bytecode, and the full viem/ethers/hardhat/foundry toolchain deploy and run without modification.
• ETH is the 18-decimal gas token; fees include an L1 data-fee component like any rollup (gas estimation basics); WebSocket subscriptions work; at ~3s blocks, stream rather than tight-poll.

The short version

Scroll (chain ID 534352) is a bytecode-equivalent zkEVM — it targets opcode-level equality with Ethereum, so existing contracts, audits, and tooling work with zero changes, and the RPC is plain eth_* (viem/ethers/foundry unchanged). As a ZK rollup it posts data to Ethereum (blobs, so Ethereum-grade DA) and reaches hard finality in ~1 hour via validity proofs — no 7-day optimistic window. The key distinction to know: Scroll aims for EVM equivalence, versus zkSync Era's EVM compatibility (different VM) and Starknet's non-EVM Cairo. If you want ZK security without relearning anything, this is the zkEVM that behaves like mainnet — just cheaper and provably correct.

Building on Scroll — DeFi that needs fast L1 finality, cross-rollup apps, or on-chain games? A flat-rate Scroll RPC endpoint gives you chain 534352 over HTTP and WebSocket alongside 75+ other chains under one key. Grab a free key and point your stack at:

https://rpc.swiftnodes.io/rpc/scroll?key=YOUR_API_KEY