eth_getLogs - Viction RPC Method

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

Why Viction? Build on the zero-gas L1 blockchain making Web3 accessible with 150 masternodes and VRC25 gasless tokens with zero-gas transactions via TomoZ, VRC25 gasless token standard, 150 masternodes, and partnerships with LayerZero and MoonPay.

When to Use This MethodCopy Anchor Link

The eth_getLogs method serves these key scenarios for consumer dApp developers, teams requiring gasless UX, and builders targeting mainstream adoption:

• Index smart contract events - Track transfers, swaps, and approvals emitted by any contract on Viction for use in indexed databases
• Monitor DeFi protocol activity - Watch for liquidity changes, price updates, and position events in real time across gasless token operations, consumer-friendly dApps, and cost-free user onboarding
• Build analytics pipelines - Extract on-chain event data for dashboards, reporting, and trend analysis on Viction
• Track token holder activity - Monitor whale movements and large transfers to detect significant market activity

Common Use CasesCopy Anchor Link

1. Monitor ERC20 Transfer EventsCopy Anchor Link

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-viction-mainnet.n.dwellir.com/YOUR_API_KEY');
const tokenAddress = '0xC054751BdBD24Ae713BA3Dc9Bd9434aBe2abc1ce';
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 EventsCopy Anchor Link

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-viction-mainnet.n.dwellir.com/YOUR_API_KEY');

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

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

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 Viction.

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

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

Each request can cover up to 500 blocks on Developer or 10,000 on Growth, Scale, and Enterprise by default. The Free plan does 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 PracticesCopy Anchor Link

• Split historical ranges into chunks within your plan limit, using smaller chunks if Viction 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 Viction, follow the eth_getLogs limits guide to size windows from the error messages instead of guessing

Code ExamplesCopy Anchor Link

Error HandlingCopy Anchor Link

Related MethodsCopy Anchor Link

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