ZKsync Era Data: Index Contracts, Smart Accounts, and ZK Chains

Index ZKsync Era contract events, token transfers, and decoded transactions in one pipeline, delivered to your own database. Account-abstraction-aware, real-time and full history, no node to run.

ZKsync Era is the flagship ZK rollup from Matter Labs, the first chain built on the ZK Stack and the first chain in the ZKsync network of ZK chains. Era runs Solidity and Vyper through an LLVM-based compiler into EraVM, a virtual machine tuned for zero-knowledge proving rather than EVM bytecode equivalence, and it launched with native account abstraction. In September 2026 ZKsync announced that EraVM chains will begin a transition within six months and that the EraVM execution environment will be retired. The team frames the vision at zksync.io.

Those same design choices reshape the data. Era is EVM-compatible at the contract and ABI level, but transaction semantics, sender identity, and the way state is published all differ from a stock EVM chain. Indexing Co covers ZKsync Era in a single pipeline, decodes the raw chain into the shape you want, and delivers it to your own PostgreSQL, warehouse, or webhook. Real-time and full history, with no node to operate.

Source ZKsync Era blocks

Ingest blocks, logs, traces

Decode EraVM and EVM ABIs

Transform your JavaScript

Deliver your database

Why ZKsync data is hard

Native Account Abstraction Era launched with native account abstraction, so any account can be a smart account and paymasters can sponsor or repay fees. A transaction's signer, its fee payer, and the address your product cares about are often three different things. An indexer that assumes a plain EOA sender mislabels who actually did what.

A Network of ZK Chains Era is one chain in the ZKsync network built on the ZK Stack, where ZK chains interoperate and move assets natively rather than through third-party bridges. Following an asset or a user across those hops means treating the network as a system, not stitching together unrelated scrapers per chain.

EVM Compatible, Not Bytecode Equivalent Era compiles Solidity and Vyper through an LLVM toolchain into EraVM, optimized for proving rather than matching EVM bytecode. Contracts and ABIs work, and a newer EVM interpreter runs unmodified bytecode on top, but gas accounting, system contracts, and low-level call patterns diverge. Decoding has to respect EraVM, not assume stock geth output.

State Diffs and Deep History Era publishes state diffs to Ethereum instead of raw transaction inputs, which compresses data availability but changes how you reconstruct state over time. Backfilling years of mainnet activity gap-free, while keeping pace with the chain head and reflecting how the rollup actually settles, is real archive-node and pipeline engineering.

What Indexing Co delivers for ZKsync

The DIY Path

Stand up and maintain the whole stack yourself.

Run a ZKsync Era archive node or wire up a third-party RPC.
Decode EraVM output against the right ABIs, plus EVM-interpreter contracts.
Untangle account-abstraction senders, paymasters, and smart-account calls.
Build state-diff reconstruction, backfill, reorg handling, and real-time delivery from scratch.

Indexing Co

One pipeline sources, decodes, and delivers Era to your store.

Era contract events, token transfers, and decoded txs in a single pipeline.
Account-abstraction-aware decoding, shaped by your JavaScript transform.
Lands in your PostgreSQL, BigQuery, warehouse, or webhook.
Real-time delivery plus complete backfilled history. No node, no RPC babysitting.

What you can index

EVM data type	On ZKsync Era, for example
Contract events and logs	SyncSwap swaps, DEX pool updates
Token transfers (ERC-20, ERC-721)	USDC payments, NFT mints on Era
Decoded transactions and traces	Smart-account calls and paymaster-sponsored txs
Protocol and account state	DEX pool reserves, vault balances, smart-account config

A transform, not a subgraph

You write the transform in JavaScript, not AssemblyScript, and change it without re-indexing from block zero. Indexing Co runs your function over each block server-side: decode the logs you care about and return rows for your destination.

// Indexing Co transform: reshape each block into rows for your database
function transform(block) {
  const results = [];
  const signatures = [
    'event Transfer(address indexed from, address indexed to, uint256 value)'
  ];

  for (const tx of block.transactions || []) {
    for (const log of tx.receipt?.logs || []) {
      const event = utils.evmDecodeLogWithMetadata(log, signatures);
      if (!event) continue;
      results.push({
        chain: block._network,
        block: Number(block.number),
        tx_hash: tx.hash,
        contract_address: log.address?.toLowerCase(),
        from: event.decoded.from,
        to: event.decoded.to,
        value: event.decoded.value,
      });
    }
  }
  return results;
}

ZKsync with Indexing Co

Run it yourself if

You want full control of node infrastructure and have the team to operate a ZKsync Era archive node, decode EraVM and account-abstraction semantics, and build state-diff reconstruction, backfill, and reorg handling in-house.

Use Indexing Co if

You want ZKsync Era contract events, token transfers, and decoded transactions delivered to your own database, account-abstraction-aware, with real-time plus complete history and no infrastructure to run.

Get a Demo Open the Console

FAQ

Do I need to run a ZKsync Era node?

No. Indexing Co sources Era blocks, logs, and traces for you, including full historical data, so you never operate an archive node or babysit an RPC endpoint.

How does Indexing Co handle account abstraction on Era?

On EraVM, every account is a potential smart account, with paymasters that can sponsor fees, so the signer, the fee payer, and the account your product cares about can all differ. Your transform receives the full transaction data, so you decide how to model who acted and who paid rather than assuming a plain EOA sender.

Era is EVM-compatible but not bytecode-equivalent. Does that matter for indexing?

Yes, and we account for it. Era compiles Solidity and Vyper through an LLVM toolchain into EraVM and also runs an EVM interpreter for unmodified bytecode. Contracts and ABIs work as you expect, while gas, system contracts, and low-level call patterns differ, so we decode against EraVM rather than assuming stock EVM output. ZKsync has announced that EraVM will be retired, with EraVM chains beginning a transition within six months of September 2026; your historical EraVM data stays decodable either way.

Where does the ZKsync Era data go?

Into your own destination: PostgreSQL, BigQuery, a warehouse, or a webhook. You define the output schema and own the storage.

Can I get complete historical ZKsync Era data?

Yes. We backfill from your chosen start block and merge it with real-time data, reconstructing state across Era's state-diff model, so your dataset is gap-free from genesis forward if you want it.

Get Started

Index ZKsync Era in minutes. Set up your first Era contract or token pipeline without running a node.