eth_getLogs - TRON RPC Method

Returns an array of all logs matching a given filter object on TRON.

Why TRON? Build on the TVM-compatible Layer 1 for TRC-20 payments, wallet APIs, and low-cost smart contract execution with TVM compatibility paired with native TRON wallet APIs, DPoS block production, and low-cost transaction flows.

When to Use This Method

The eth_getLogs method serves these key scenarios for TRON developers building payment rails, exchanges, and consumer crypto applications:

• Index smart contract events - Track transfers, swaps, and approvals emitted by any contract on TRON for use in indexed databases
• Monitor DeFi protocol activity - Watch for liquidity changes, price updates, and position events in real time across TRC-20 transfers, wallet operations, and EVM-compatible smart contract integrations
• Build analytics pipelines - Extract on-chain event data for dashboards, reporting, and trend analysis on TRON
• Track token holder activity - Monitor whale movements and large transfers to detect significant market activity

Common Use Cases

1. Monitor ERC20 Transfer Events

Track all transfer events for a specific token contract within a defined block range. The Transfer event signature hash filters for exactly this event type, and you can optionally filter by sender or recipient address using indexed topics.

import { JsonRpcProvider } from 'ethers';

const provider = new JsonRpcProvider('https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/jsonrpc');
const tokenAddress = '0xc7885b2334355ba766f54a3ad14d5a5339934bb3';
const transferTopic = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';

async function getRecentTransfers(fromBlock, toBlock) {
  const logs = await provider.getLogs({
    address: tokenAddress,
    fromBlock: fromBlock,
    toBlock: toBlock,
    topics: [transferTopic]
  });

  const transfers = logs.map(log => ({
    from: '0x' + log.topics[1].slice(26),
    to: '0x' + log.topics[2].slice(26),
    amount: BigInt(log.data).toString(),
    txHash: log.transactionHash
  }));

  console.log(`Found ${transfers.length} transfers`);
  return transfers;
}

const recentTransfers = await getRecentTransfers('latest', 'latest');

2. Track DEX Swap Events

Capture swap events from a DEX to analyze trading volume, price impact, and liquidity flow. Each swap emits event parameters that include the amounts and addresses involved - ideal for building price feeds and volume aggregators.

const provider = new JsonRpcProvider('https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/jsonrpc');

const SWAP_TOPIC = '0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822';
const pairAddress = '0xc7885b2334355ba766f54a3ad14d5a5339934bb3';

async function getRecentSwaps(fromBlock, toBlock) {
  const logs = await provider.getLogs({
    address: pairAddress,
    fromBlock: fromBlock,
    toBlock: toBlock,
    topics: [SWAP_TOPIC]
  });

  return logs.map(log => ({
    sender: '0x' + log.topics[1].slice(26),
    to: '0x' + log.topics[2].slice(26),
    amount0In: BigInt('0x' + log.data.slice(2, 66)).toString(),
    amount1In: BigInt('0x' + log.data.slice(66, 130)).toString(),
    amount0Out: BigInt('0x' + log.data.slice(130, 194)).toString(),
    amount1Out: BigInt('0x' + log.data.slice(194, 258)).toString(),
    txHash: log.transactionHash
  }));
}

const swaps = await getRecentSwaps('latest', 'latest');
console.log(`Found ${swaps.length} swaps`);

3. Multi-Contract Event Aggregation

Query events from multiple contracts simultaneously by passing an array of addresses. This is useful for cross-protocol analytics - aggregating lending, borrowing, and liquidation events from multiple DeFi protocols in a single query on TRON.

const provider = new JsonRpcProvider('https://api-tron-mainnet.n.dwellir.com/YOUR_API_KEY/jsonrpc');

const contracts = [
  '0xContractA...',
  '0xContractB...',
  '0xContractC...'
];

const EVENT_TOPIC = '0x...';

async function aggregateEvents(fromBlock, toBlock) {
  const logs = await provider.getLogs({
    address: contracts,
    fromBlock: fromBlock,
    toBlock: toBlock,
    topics: [EVENT_TOPIC]
  });

  const grouped = {};
  for (const log of logs) {
    const contract = log.address;
    if (!grouped[contract]) grouped[contract] = [];
    grouped[contract].push(log);
  }

  for (const [contract, events] of Object.entries(grouped)) {
    console.log(`${contract}: ${events.length} events`);
  }

  return grouped;
}

aggregateEvents('0x100000', '0x1000c7');

Block-range limits

Each request can cover up to 500 blocks on Developer or 10,000 on Growth, Scale, and Enterprise by default. Free and Starter do not include eth_getLogs. Both endpoint blocks count: toBlock - fromBlock + 1. Address and topic filters do not increase this allowance. Individual networks may enforce lower limits.

Supply block bounds or a blockHash. Do not combine a non-null hash with non-null bounds. Missing or null bounds default to latest. Equal tags request one block. Numeric ranges ending at latest or pending use the observed endpoint head plus a 6-block margin for validation. Use explicit numeric bounds for exact pagination. Mixed ranges involving safe or finalized are rejected. The earliest tag means block zero.

Range errors return HTTP 200 with a JSON-RPC error body. Oversized ranges use code -32005, invalid bounds use -32602, and an unavailable endpoint head uses -32000. WebSocket uses the same JSON-RPC codes. The same range validation applies to eth_newFilter. A rejected log query rejects its entire batch before any member executes. See request examples and pagination guidance.

Best Practices

• Split historical ranges into chunks within your plan limit, using smaller chunks if TRON enforces a lower limit.
• Use topic filters for efficient log filtering: the node filters at the storage level before returning results
• For high-volume monitoring, use eth_newFilter with polling instead of repeatedly calling eth_getLogs
• Store the last processed block number for incremental indexing rather than re-scanning the full chain
• Budget for the split: each chunk is a separate request billed as one response at the standard 1 credit, so a wide backfill costs proportionally more on a plan with a smaller limit
• For long backfills on TRON, follow the eth_getLogs limits guide to size windows from the error messages instead of guessing

Code Examples

Error Handling

Related Methods

• eth_newFilter - Create a filter for logs
• eth_getFilterChanges - Poll filter for new logs