Your chain events, in your own Postgres.
Give it an ABI, a contract address, and an RPC. Arckive streams every on-chain event into your own PostgreSQL — one table per event, reliable and gap-free — from a single YAML manifest.
| Name | Phase | Current | Head | Lag |
|---|---|---|---|---|
| usdc-arc | Provisioning | — | — | — |
Status is patched onto the resource itself. No dashboard to log into.
Dune is delayed and rate-limited. Raw logs leave reorgs and back-fill to you. The Graph means subgraphs and heavy ops. There was no declarative path to your events, in your Postgres, in plain SQL.
Declare it. The operator does the rest.
One Indexer resource describes what you want. A Kubernetes operator keeps it true — database, schema, listener, optional read API.
Write one manifest
Contracts, ABI ref, RPC pool, storage mode — the whole setup.
kind: Indexer metadata: { name: usdc-arc } spec: rpc: # health-checked failover - https://rpc.arc.example storage: { mode: Embedded } contracts: - address: "0xA0b8…eB48" abi: { configMapRef: usdc-abi } startBlock: 0
The operator provisions
A reconcile loop turns the spec into running parts — and heals them.
Pod dies? Config drifts? It converges back.
Query plain SQL
Each event is a table in your Postgres. No API between you and your data.
-- one table per event SELECT "from", "to", value FROM usdc_transfer WHERE value > 1000000000 ORDER BY block_number DESC;
ABI in → tables out · empty events list = every event · startBlock: 0 backfills from genesis
On the shelves now
Schema idx_usdc_arc · one table per event, typed from the ABI, unique on (block, tx, log).
transferidx_usdc_arc
from, to text · value numeric(78,0)
approvalidx_usdc_arc
owner, spender text · value numeric(78,0)
the checkpoint a restart resumes from
reserved for indexer metadata
lettercontrol
empty when healthy
Even if the network blips, no data is lost.
A poll-based backbone chosen for loss-free, self-healing ingestion — not just latency. Don't take our word for it: break something.
The last processed block lives in Postgres. After any crash it resumes exactly there.
Event inserts and cursor advance share one transaction — a commit, or nothing.
Indexes to the finalized tag — BFT finality means finalized blocks never reorg.
A health-checked pool with rotation, backoff, circuit-breaker. A blip never becomes a gap.
Latest events
Open in SQLProvisioning — the first row lands once the worker is up.
Measured, not promised.
Every number comes from running the real worker against the public Arc testnet and reading only its production surface — Postgres rows and /metrics. Reproduce it with pnpm bench.
newHeads listening, not polling. Even p99 stays under a second (0.97 s).The budget is published too: the head signal is consumed straight from the newHeads payload and one parallel eth_getLogs round-trip later the row is committed. The engine itself adds about 40 ms; the rest belongs to how fast the RPC announces blocks, and it shrinks further with a cluster-local Arc node. Full methodology and raw results: benchmark report · docs/benchmarks.
A specific combination nobody else offers.
| Dune | The Graph | Raw RPC | Arckive | |
|---|---|---|---|---|
| Data in your own DB | No | Via graph-node | If you build it | Yes |
| Plain SQL access | Dune SQL only | GraphQL | Raw JSON | Yes |
| Reorg & gap handling | Theirs | Yes | On you | Built-in |
| Setup effort | Low | Med–high | High | One YAML |
Honest positioning: Dune stays great for ad-hoc analytics; The Graph for hosted multi-chain. Arckive is for teams that want their own Postgres, plain SQL, and K8s-native ops — together.
One YAML. A running indexer.
Runs in your cluster. Your data never leaves it.
kubectl apply -f https://arckive.org/install.yaml