eth_syncing - zkSync RPC Method

Returns the sync status of your zkSync Era node - either false when fully synced, or an object describing the sync progress.

Why zkSync? Build on Matter Labs' flagship zkEVM powering the Elastic Network of interoperable hyperchains with ZK Stack modular framework, hyperchain interoperability, native account abstraction, and $1.9B in tokenized real-world assets.

When to Use This Method

eth_syncing is essential for ZK developers, RWA tokenization teams, and builders launching custom L2/L3 chains:

• Node Health Checks - Verify your node is fully synced before processing transactions
• Sync Progress Monitoring - Track how far behind your node is during initial sync or after downtime
• Load Balancer Routing - Route requests only to fully synced nodes in multi-node setups
• dApp Reliability - Display sync warnings to users when data may be stale

Code Examples

Common Use Cases

1. Node Health Monitor

Continuously check sync status and alert on issues:

async function monitorNodeHealth(provider, interval = 30000) {
  setInterval(async () => {
    const syncing = await provider.send('eth_syncing', []);

    if (syncing === false) {
      const blockNumber = await provider.getBlockNumber();
      const block = await provider.getBlock(blockNumber);
      const age = Date.now() / 1000 - block.timestamp;

      if (age > 60) {
        console.warn(`Node synced but block is ${age.toFixed(0)}s old`);
      } else {
        console.log(`Healthy - block ${blockNumber}`);
      }
    } else {
      const current = parseInt(syncing.currentBlock, 16);
      const highest = parseInt(syncing.highestBlock, 16);
      console.warn(`Syncing: ${highest - current} blocks behind`);
    }
  }, interval);
}

2. Wait for Sync Before Processing

Block application startup until the node is ready:

async function waitForSync(provider, pollInterval = 5000) {
  while (true) {
    const syncing = await provider.send('eth_syncing', []);

    if (syncing === false) {
      console.log('Node synced - ready to process transactions');
      return;
    }

    const current = parseInt(syncing.currentBlock, 16);
    const highest = parseInt(syncing.highestBlock, 16);
    console.log(`Waiting for sync: ${highest - current} blocks remaining...`);
    await new Promise(r => setTimeout(r, pollInterval));
  }
}

Best Practices

• Poll eth_syncing at application startup and block all transaction operations until false is returned
• Check both the sync status AND the latest block timestamp age -- a node can report synced but still have stale data
• In multi-node setups, route read requests to synced nodes and avoid sending transactions to nodes still catching up
• For long-running services, implement a health check that raises alerts if the sync gap exceeds a threshold
• Some client implementations return a sync object with additional fields like knownStates and pulledStates during state sync

Error Handling

Related Methods

• eth_blockNumber - Get current block height
• net_peerCount - Check peer connections
• net_listening - Verify node is accepting connections
• web3_clientVersion - Get node client info