Docs
Docs
Home
Getting Started
Agent Tooling
CLI
Supported Chains
Acala
Aptos
Arbitrum
Arc
Asset Hub
Astar
Avalanche
Base
Berachain
Bifrost
Binance Smart Chain
Bittensor
Blast
Boba Network
Bridge Hub
Celo
Centrifuge
Chiliz
Cronos
Enjin
Ethereum
Etherlink
Flow EVM Gateway
Gnosis
Hydration
Hyperliquid
Immutable
Ink
IoTeX
Kusama
Linea
LISK
Manta Atlantic
Manta Pacific
Mantle
MegaETH
Monad
Movement
Neuroweb
opBNB
Optimism
Plasma
Polkadot
Polygon
Pulsechain
Robinhood
Ronin
Scroll
Sonic
Starknet
Taiko
Tempo
Sui
TRON
Unichain
Viction
World Chain
XDC Network
XX Network
Zetachain
zkSync Era
Zora
Supported ChainsLineaJSON-RPC APIBlock Methods

eth_blockNumber - Linea RPC Method

Get the current block height on Linea. Essential for syncing dApps, monitoring transaction confirmations, and blockchain state tracking.

Linea RPC endpoint: endpoint URLs, plans and pricing.

Returns the number of the most recent block on Linea.

Why Linea? Build on Consensys-backed zkEVM L2 with $1B+ TVL and 807% growth in 2025 with 15-30x lower fees than Ethereum mainnet, 6,200 TPS throughput, SWIFT integration with 12+ institutions, and $725M Consensys backing.

When to Use This Method

eth_blockNumber is fundamental for enterprise developers, DeFi builders, and teams seeking Consensys ecosystem integration:

  • Syncing Applications - Keep your dApp in sync with the latest Linea blockchain state
  • Transaction Monitoring - Verify confirmations by comparing block numbers
  • Event Filtering - Set the correct block range for querying logs on enterprise DeFi (Aave, Renzo), institutional cross-border payments via SWIFT pilots, and zkEVM-native applications
  • Health Checks - Monitor node connectivity and sync status
JSON-RPC request
{
  "jsonrpc": "2.0",
  "method": "eth_blockNumber",
  "params": [],
  "id": 1
}

Code Examples

Common Use Cases

1. Block Confirmation Counter

Monitor transaction confirmations on Linea:

JavaScript
async function getConfirmations(provider, txHash) {
  const tx = await provider.getTransaction(txHash);
  if (!tx || !tx.blockNumber) return 0;

  const currentBlock = await provider.getBlockNumber();
  return currentBlock - tx.blockNumber + 1;
}

// Wait for specific confirmations
async function waitForConfirmations(provider, txHash, confirmations = 6) {
  let currentConfirmations = 0;

  while (currentConfirmations < confirmations) {
    currentConfirmations = await getConfirmations(provider, txHash);
    console.log(`Confirmations: ${currentConfirmations}/${confirmations}`);
    await new Promise(r => setTimeout(r, 2000));
  }

  return true;
}

2. Event Log Filtering

Query events from recent blocks on Linea:

JavaScript
async function getRecentEvents(provider, contract, eventName, blockRange = 100) {
  const currentBlock = await provider.getBlockNumber();
  const fromBlock = currentBlock - blockRange;

  const filter = contract.filters[eventName]();
  const events = await contract.queryFilter(filter, fromBlock, currentBlock);

  return events;
}

3. Node Health Monitoring

Check if your Linea node is synced:

JavaScript
async function checkNodeHealth(provider) {
  try {
    const blockNumber = await provider.getBlockNumber();
    const block = await provider.getBlock(blockNumber);

    const now = Date.now() / 1000;
    const blockAge = now - block.timestamp;

    if (blockAge > 60) {
      console.warn(`Node may be behind. Last block was ${blockAge}s ago`);
      return false;
    }

    console.log(`Node healthy. Latest block: ${blockNumber}`);
    return true;
  } catch (error) {
    console.error('Node unreachable:', error);
    return false;
  }
}

Performance Optimization

Caching Strategy

Cache block numbers to reduce API calls:

JavaScript
class BlockNumberCache {
  constructor(ttl = 2000) {
    this.cache = null;
    this.timestamp = 0;
    this.ttl = ttl;
  }

  async get(provider) {
    const now = Date.now();

    if (this.cache && (now - this.timestamp) < this.ttl) {
      return this.cache;
    }

    this.cache = await provider.getBlockNumber();
    this.timestamp = now;
    return this.cache;
  }

  invalidate() {
    this.cache = null;
    this.timestamp = 0;
  }
}

const blockCache = new BlockNumberCache();

Batch Requests

Combine with other calls for efficiency:

JavaScript
const batch = [
  { jsonrpc: '2.0', method: 'eth_blockNumber', params: [], id: 1 },
  { jsonrpc: '2.0', method: 'eth_gasPrice', params: [], id: 2 },
  { jsonrpc: '2.0', method: 'eth_chainId', params: [], id: 3 }
];

const response = await fetch('https://api-linea-mainnet-archive.n.dwellir.com/YOUR_API_KEY', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(batch)
});

const results = await response.json();

Error Handling

Common errors and solutions:

Error CodeDescriptionSolution
-32603Internal errorRetry with exponential backoff
-32005Rate limit exceededImplement rate limiting client-side
-32000Execution revertedCheck node sync status
JavaScript
async function safeGetBlockNumber(provider, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await provider.getBlockNumber();
    } catch (error) {
      if (error.code === -32005) {
        await new Promise(r => setTimeout(r, Math.pow(2, i) * 1000));
      } else if (i === maxRetries - 1) {
        throw error;
      }
    }
  }
}

Related Methods

  • eth_getBlockByNumber - Get full block details by number
  • eth_getBlockByHash - Get block details by hash
  • eth_syncing - Check if node is still syncing

Linea - zkEVM Layer 2 Documentation

Complete guide to Linea zkEVM integration with Dwellir RPC. Learn how to build on Linea's zero-knowledge rollup, access JSON-RPC methods, and optimize your dApp performance.

eth_getBlockByNumber

Retrieve complete block data by block number on Linea. Perfect for enterprise developers, DeFi builders, and teams seeking Consensys ecosystem integration building on Consensys-backed zkEVM L2 with $1B+ TVL and 807% growth in 2025.

On this page

When to Use This MethodCode ExamplesCommon Use Cases1. Block Confirmation Counter2. Event Log Filtering3. Node Health MonitoringPerformance OptimizationCaching StrategyBatch RequestsError HandlingRelated Methods