Astar Data: Index EVM Transactions and dApp Staking on Polkadot
Index Astar Network's EVM transactions, dApp Staking calls, and native extrinsics in one pipeline, delivered to your own database. Real-time and complete historical data, no node to run.
Astar describes itself as a web3 collective building products that bring users onchain, anchored by Astar Network and the ASTR token, with activity spanning Astar Network, Soneium, Ethereum, and Polkadot. Astar Network itself is a Substrate parachain on Polkadot that runs EVM smart contracts (new WASM contract deployments have been frozen since June 2026), plus a native dApp Staking system where ASTR holders lock and stake behind the apps they back. You can read how the team frames it at astar.network and in the Astar docs.
That mix is the data problem. On Astar, an EVM transaction is not a standalone EVM block entry: it arrives as an ethereum.transact extrinsic inside a Substrate block, next to native calls like dappStaking.stake that are often wrapped in utility.batchAll. Indexing Co covers Astar in a single pipeline, lets you split and shape both sides into rows, and delivers them to your own PostgreSQL, warehouse, or webhook. Real-time and full history, with no node to operate.
Why Astar data is hard
ethereum.transact extrinsics. The payload is a typed envelope (Legacy, EIP1559, and so on) with the target, value, gas, and calldata. Reading it means unwrapping the envelope inside a Substrate block, not pulling a plain EVM transaction list.
dappStaking.lock, dappStaking.stake, and dappStaking.claimStakerRewards, which an EVM-only indexer never sees. Stake targets can be EVM contract addresses, so the two worlds reference each other.
utility.batchAll extrinsic. The outer method says nothing useful: you have to walk the nested section and method pairs to count what actually happened.
What Indexing Co delivers for Astar
Stand up and maintain both stacks yourself.
- Run an Astar archive node, or a Substrate RPC plus an EVM RPC.
- Decode extrinsics against runtime metadata and unwrap
ethereum.transactenvelopes. - Flatten
utilitybatches into individual dApp Staking actions. - Build backfill, runtime-upgrade handling, and delivery from scratch.
One pipeline sources, decodes, and delivers Astar to your store.
- Every extrinsic with method, signer, nonce, hash, and decoded args, EVM envelopes included.
- Shaped by your JavaScript transform: split EVM from native, expand batches.
- Lands in your PostgreSQL, BigQuery, warehouse, or webhook.
- Real-time delivery plus complete backfilled history. No node, no RPC babysitting.
What you can index
| Astar extrinsic data | On Astar, for example |
|---|---|
| EVM transactions | ethereum.transact target, value, gas, calldata, and selector |
| dApp Staking | dappStaking.lock, dappStaking.stake, dappStaking.claimStakerRewards |
| Batched native calls | Inner calls of utility.batchAll |
| Signers and nonces | Per-account native activity |
| Block headers | Block number, hash, parent hash, and timestamp.set time |
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: pick the extrinsics you care about and return rows for your destination.
// Indexing Co transform: split Astar EVM transactions from native calls
function transform(block) {
const results = [];
const base = { chain: block._network, block: block.blockNumber };
for (const ext of block.extrinsics || []) {
if (ext.method === 'ethereum.transact') {
const [envelope] = ext.args;
const txType = Object.keys(envelope)[0]; // Legacy, EIP1559, ...
const tx = envelope[txType];
results.push({
...base,
extrinsic_hash: ext.hash,
kind: 'evm',
tx_type: txType,
to: tx.action.Call || null,
value: tx.value.replace(/,/g, ''),
selector: tx.input.slice(0, 10),
});
} else if (ext.method.startsWith('utility.batch')) {
// batched native calls arrive as { section, method, args }
for (const inner of ext.args[0]) {
results.push({
...base,
extrinsic_hash: ext.hash,
kind: 'native',
signer: ext.signer,
call: inner.section + '.' + inner.method,
});
}
} else if (!['timestamp.set', 'parachainSystem.setValidationData'].includes(ext.method)) {
results.push({ ...base, extrinsic_hash: ext.hash, kind: 'native', signer: ext.signer, call: ext.method });
}
}
return results;
}
Astar with Indexing Co
You want full control of infrastructure and have the team to operate an Astar archive node, decode both EVM envelopes and Substrate calls, and build backfill and delivery in-house.
You want Astar EVM transactions and dApp Staking activity delivered to your own database as clean rows, with real-time plus complete history and no node to run.
Related Reading
FAQ
Does Indexing Co cover Astar's EVM side?
Yes, at the transaction level. EVM transactions arrive as ethereum.transact extrinsics with their full envelope: type, nonce, gas, target address, value, and calldata. Your transform can read the function selector from the calldata and route rows by contract.
Can I track dApp Staking?
Yes. dApp Staking actions such as dappStaking.lock, dappStaking.stake, and dappStaking.claimStakerRewards arrive as native extrinsics with their signer and arguments, including when they are bundled inside utility.batchAll.
What is in each Astar block?
The block number, block hash, and header, plus an array of extrinsics. Each extrinsic carries its index, hash, signer, nonce, method in pallet.call form, and its decoded arguments.
Do I need to run an Astar node?
No. Indexing Co sources Astar blocks for you, including full history, so you never operate an archive node or juggle separate Substrate and EVM endpoints.
Where does the Astar 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 Astar in minutes. Set up your first EVM or dApp Staking pipeline without running a node.