In our last blog post we covered RPCs, how your app talks to a blockchain node in real time. RPCs are essential, but they only get you so far. The moment you need to ask a question that spans multiple blocks, multiple contracts, or any kind of historical range, the RPC can't help you, and that's where indexing comes in.
Hgraph runs its own indexing infrastructure, it's a big part of what we do. This post explains what indexing actually is, why raw node data isn't enough, and how it all fits together.
What You Get From an RPC
An RPC gives you direct access to the current state of the chain. You can look up a single block, fetch a specific transaction, check a wallet's current balance, or call a smart contract function. It's fast and it works well for "give me this one thing right now."
What it can't do is answer questions across the chain. A few examples:
"Show me all ERC-20 transfers for this wallet in the last 30 days." There's no index by wallet, you'd have to scan millions of blocks.
"What NFTs does this wallet hold?" There's no global ownership index, you'd need to query every ERC-721 contract individually.
"What's the transfer volume for this token this week?" There's no aggregation, you'd scan every block and determine the sum yourself.
"Give me a list of all holders of this token with balances over 1M." The way token balances are stored onchain, you can't just pull a list of holders. You'd have to replay every Transfer event from the contract's entire history to reconstruct who holds what.
The RPC gives you one thing at a time, a block, a transaction, a balance. It's not built to search, filter, or aggregate across the chain. If your app needs to answer questions that span blocks, contracts, or time ranges, you need an indexing layer.
What an Indexer Does
An indexer watches the chain block by block, decodes the raw data, and writes it into a structured database.
Here's what that looks like in practice. When a new block comes in, the indexer pulls the block header, all transactions, receipts, and event logs. Raw event logs on the EVM are just hex, a keccak256 hash for the event signature, zero-padded addresses, and ABI-encoded values. The indexer decodes all of that using the contract's ABI, turning opaque bytes into typed fields: event name, from address, to address, amount, token symbol, decimals, timestamp.
The raw version of an ERC-20 transfer looks like this:
{
"topics": [
"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
"0x000000000000000000000000ab5801a7d398351b8be11c439e05c5b3259aec9b",
"0x0000000000000000000000004838b106fce9647bdf1e7877bf73ce8b0bad5f97"
],
"data": "0x0000000000000000000000000000000000000000000000056bc75e2d63100000"
}
After indexing, that becomes:
{
"event": "Transfer",
"token_symbol": "UNI",
"from": "0xab58...ec9b",
"to": "0x4838...5f97",
"amount": 100.0,
"timestamp": "2023-06-15T14:32:11Z"
}
The decoded record sits in a transfer table with indexes on sender, recipient, token, and timestamp. Now "all transfers for wallet X in the last 30 days" is a fast query instead of a full chain scan.
How It Fits With RPC
RPC and indexed data aren't competing, they cover different use cases.
RPC gives you real-time, point-in-time access; think current balances, sending transactions, calling contract functions, or reading the latest block. If your app needs to write to the chain or check the current state, you'd use the RPC.
Indexed data gives you historical, queryable, structured data access. Transfer history, holder lists, token metadata, aggregated metrics, time-series data, etc. If your app needs to display a portfolio, build a dashboard, power search, or run analytics, you'd use the indexer.
Most production apps need both.
What Hgraph Indexes
We run bare-metal infrastructure hosting our own nodes backed by PostgreSQL. On top of that we've built a custom indexing pipeline, not subgraphs, not a third-party data warehouse, but our own stack designed around the specific data we need to serve.
Right now, we index ERC-20, ERC-721, and ERC-1400 token data on Hedera, plus the full Hedera mirror node dataset, which includes transactions, entities, token accounts, contract state, staking data, and more. All of this data is available through GraphQL, REST, JSON-RPC, and SQL. We have a few playgrounds available in our app, if you're interested in testing them out.
Indexed Ethereum data is what we're building next. The Ethereum RPC is now live, and the indexing layer is a work in progress. Same approach, structured, queryable data served through a single API.
Docs can be found at docs.hgraph.com.