eth_syncing - Mantle RPC Method

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

Why Mantle? Build on the world's largest ZK rollup by TVL with $2.5B+ secured and deep Bybit integration with near-instant ZK finality via OP Succinct, $6.2B treasury backing, mETH liquid staking, and 25% Bybit trading fee discounts.

When to Use This MethodCopy Anchor Link

eth_syncing is essential for DeFi developers, liquid staking builders, and teams seeking institutional exchange integration:

• 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

{
  "jsonrpc": "2.0",
  "method": "eth_syncing",
  "params": [],
  "id": 1
}

Code ExamplesCopy Anchor Link

Common Use CasesCopy Anchor Link

1. Node Health MonitorCopy Anchor Link

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 ProcessingCopy Anchor Link

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 PracticesCopy Anchor Link

• 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 HandlingCopy Anchor Link

Related MethodsCopy Anchor Link

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