eth_newPendingTransactionFilter | zkSync Era RPC

Create a filter for pending transaction notifications on zkSync Era. Essential for mempool monitoring, transaction tracking, and MEV opportunity detection for RWA tokenization ($1.9B, 25% market share), hyperchain deployment via ZK Stack, and cross-chain DeFi.

Creates a filter on zkSync Era that notifies when new pending transactions are added to the mempool. Once created, poll the filter with eth_getFilterChanges to receive an array of transaction hashes for pending transactions that have appeared since your last poll.

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_newPendingTransactionFilter is essential for ZK developers, RWA tokenization teams, and builders launching custom L2/L3 chains:

Mempool Monitoring — Observe unconfirmed transactions on zkSync to understand network activity and congestion
Transaction Tracking — Detect when a specific transaction enters the mempool before it is mined
MEV Opportunity Detection — Identify arbitrage, liquidation, or sandwich opportunities by watching pending transactions
Gas Price Estimation — Analyze pending transactions to estimate optimal gas pricing for RWA tokenization ($1.9B, 25% market share), hyperchain deployment via ZK Stack, and cross-chain DeFi

async function mempoolDashboard(provider) {
  const filterId = await provider.send('eth_newPendingTransactionFilter', []);

  const stats = {
    totalSeen: 0,
    contractCalls: 0,
    transfers: 0,
    intervalStart: Date.now()
  };

  setInterval(async () => {
    const txHashes = await provider.send('eth_getFilterChanges', [filterId]);
    stats.totalSeen += txHashes.length;

    for (const hash of txHashes) {
      try {
        const tx = await provider.getTransaction(hash);
        if (!tx) continue;

        if (tx.data && tx.data !== '0x') {
          stats.contractCalls++;
        } else {
          stats.transfers++;
        }
      } catch (e) {
        // Transaction may have been mined or dropped
      }
    }

    const elapsed = (Date.now() - stats.intervalStart) / 1000;
    const txPerSec = (stats.totalSeen / elapsed).toFixed(1);
    console.log(`Mempool: ${stats.totalSeen} txs (${txPerSec}/s) | Calls: ${stats.contractCalls} | Transfers: ${stats.transfers}`);
  }, 2000);
}

2. Track Specific Address Activity

Watch for pending transactions involving a target address:

JavaScript

async function watchAddress(provider, targetAddress) {
  const filterId = await provider.send('eth_newPendingTransactionFilter', []);
  const target = targetAddress.toLowerCase();

  console.log(`Watching pending transactions for ${targetAddress}...`);

  setInterval(async () => {
    const txHashes = await provider.send('eth_getFilterChanges', [filterId]);

    for (const hash of txHashes) {
      try {
        const tx = await provider.getTransaction(hash);
        if (!tx) continue;

        const isFrom = tx.from?.toLowerCase() === target;
        const isTo = tx.to?.toLowerCase() === target;

        if (isFrom || isTo) {
          console.log(`Pending tx detected for ${targetAddress}:`);
          console.log(`  Hash: ${hash}`);
          console.log(`  Direction: ${isFrom ? 'OUTGOING' : 'INCOMING'}`);
          console.log(`  Value: ${tx.value} wei`);
          console.log(`  Gas price: ${tx.gasPrice} wei`);
        }
      } catch (e) {
        // Transaction already mined or dropped
      }
    }
  }, 1000);
}

3. Large Transaction Alert System

Detect high-value pending transactions:

JavaScript

async function largeTransactionAlerts(provider, thresholdEth = 10) {
  const filterId = await provider.send('eth_newPendingTransactionFilter', []);
  const thresholdWei = BigInt(thresholdEth * 1e18);

  setInterval(async () => {
    const txHashes = await provider.send('eth_getFilterChanges', [filterId]);

    for (const hash of txHashes) {
      try {
        const tx = await provider.getTransaction(hash);
        if (!tx || !tx.value) continue;

        if (BigInt(tx.value) >= thresholdWei) {
          const ethValue = Number(BigInt(tx.value)) / 1e18;
          console.log(`LARGE TX: ${ethValue.toFixed(4)} ETH`);
          console.log(`  From: ${tx.from}`);
          console.log(`  To: ${tx.to}`);
          console.log(`  Hash: ${hash}`);
        }
      } catch (e) {
        // Transaction may have already been mined
      }
    }
  }, 1000);
}

Error Handling

Common errors and solutions:

Error Code	Description	Solution
-32603	Internal error	Node may not expose mempool data — check node configuration
-32000	Filter not found	Filter expired (~5 min inactivity) — recreate with `eth_newPendingTransactionFilter`
-32005	Rate limit exceeded	Reduce polling frequency — mempool can be very active
-32601	Method not found	Node does not support pending transaction filters — requires a full node with txpool enabled

JavaScript

async function createPendingTxFilter(provider) {
  try {
    const filterId = await provider.send('eth_newPendingTransactionFilter', []);
    return { supported: true, filterId };
  } catch (error) {
    if (error.code === -32601 || error.message.includes('not found')) {
      console.warn('Pending transaction filter not supported by this node');
      console.warn('This method requires a full node with txpool access');
      return { supported: false };
    }
    throw error;
  }
}

eth_getFilterChanges — Poll this filter for new pending transaction hashes
eth_uninstallFilter — Remove the filter when no longer needed
eth_getTransactionByHash — Fetch full transaction details for hashes returned by the filter
eth_sendRawTransaction — Submit a transaction that will appear in the pending pool

eth_newPendingTransactionFilter - zkSync RPC Method

When to Use This Method

Code Examples

Common Use Cases

1. Mempool Activity Dashboard

2. Track Specific Address Activity

3. Large Transaction Alert System

Error Handling

On this page