Aurora Data: Index EVM Contracts on NEAR

Index Aurora's contract events, token transfers, and decoded transactions in one pipeline, delivered to your own database. Real-time and complete historical data no node to run.

Aurora is an EVM built with the Aurora Engine that runs on the NEAR Protocol, so it gives you full Ethereum tooling and Solidity compatibility while settling on NEAR's high-throughput base layer. The result is Ethereum-familiar contracts, low fees, and NEAR-backed scalability. You can read how the team frames it at aurora.dev.

That hybrid design is the data problem. Aurora looks like any EVM from the outside, but every block is produced by an Engine contract running on NEAR, and the contract events, token transfers, and decoded calls you need have to be captured correctly from that layer. Indexing Co covers Aurora in a single pipeline, decodes the raw chain into the shape you want, and delivers it to your own PostgreSQL, warehouse, or webhook. Real-time and full history, with no node to operate.

Source Aurora EVM blocks

Ingest blocks, logs, traces

Decode ABIs to events

Transform your JavaScript

Deliver your database

Why Aurora data is hard

EVM Contracts, NEAR Underneath Aurora runs the Aurora Engine as a contract on NEAR, so your Solidity contracts and ABIs work exactly as they do on Ethereum, but the chain settles through NEAR's runtime. You want an indexer that treats Aurora as a first-class EVM while staying correct about how the Engine surfaces blocks, logs, and receipts.

Decoding Across Many Contracts A real Aurora dataset spans multiple protocols at once: DEX pools, lending markets, bridged assets, and your own deployments. Each needs its own ABI and event handling, and proxy contracts make the right ABI a moving target as implementations upgrade.

Your Own DB, Not a Hosted API Generic RPC endpoints and hosted query APIs leave you rate-limited and renting someone else's schema. Powering an app or analytics workload on Aurora means owning the data in your own store, shaped the way your product queries it.

What Indexing Co delivers for Aurora

The DIY Path

Stand up and maintain the whole stack yourself.

Run an Aurora archive node or wire up a third-party RPC.
Fetch and decode logs, traces, and receipts against the right ABIs.
Track proxy upgrades and per-protocol event schemas by hand.
Build backfill, reorg handling, and real-time delivery from scratch.

Indexing Co

One pipeline sources, decodes, and delivers Aurora to your store.

Aurora contract events, token transfers, and decoded txs in a single pipeline.
Lands in your PostgreSQL, BigQuery, warehouse, or webhook.
Real-time delivery plus complete backfilled history. No node, no RPC babysitting.

What you can index

EVM data type	On Aurora, for example
Contract events and logs	DEX swaps, lending borrows and repays
Token transfers (ERC-20, ERC-721)	Bridged stablecoin payments, NFT mints
Decoded transactions and traces	Aurora Engine calls, account operations
Protocol and account state	Pool reserves, lending positions, token balances

A transform, not a subgraph

You write the transform in JavaScript, not AssemblyScript, and change it without re-indexing from block zero. Indexing Co runs your function over each block server-side: decode the logs you care about and return rows for your destination.

// Indexing Co transform: reshape each block into rows for your database
function transform(block) {
  const results = [];
  const signatures = [
    'event Transfer(address indexed from, address indexed to, uint256 value)'
  ];

  for (const tx of block.transactions || []) {
    for (const log of tx.receipt?.logs || []) {
      const event = utils.evmDecodeLogWithMetadata(log, signatures);
      if (!event) continue;
      results.push({
        chain: block._network,
        block: Number(block.number),
        tx_hash: tx.hash,
        contract_address: log.address?.toLowerCase(),
        from: event.decoded.from,
        to: event.decoded.to,
        value: event.decoded.value,
      });
    }
  }
  return results;
}

Aurora with Indexing Co

Run it yourself if

You want full control of node infrastructure and have the team to operate an Aurora archive node, decode every protocol's ABIs, and build backfill and reorg handling in-house.

Use Indexing Co if

You want Aurora contract events, token transfers, and decoded transactions delivered to your own database, with real-time plus complete history and no infrastructure to run.

Get a Demo Open the Console

FAQ

Do I need to run an Aurora node?

No. Indexing Co sources Aurora blocks, logs, and traces for you, including full historical data, so you never operate an archive node or babysit an RPC endpoint.

Can I index any protocol on Aurora?

Yes. Point a pipeline at any Aurora contract or set of contracts, from DEXes and lending markets to bridged assets or your own deployments, and we decode the events against the right ABI.

Does Indexing Co handle Aurora reorgs and proxy upgrades?

Yes. The pipeline accounts for chain reorganizations and tracks proxy implementation changes so your decoded data stays correct as contracts upgrade.

Where does the Aurora data go?

Into your own destination: PostgreSQL, BigQuery, a warehouse, or a webhook. You define the output schema and own the storage.

Get Started

Index Aurora in minutes. Set up your first Aurora contract or token pipeline without running a node.