✱ Verified-real event delivery

Events you can trust are real.

EVM contract events with an explicit trust status — multi-source attested, reorg-aware, and resilient to any single provider failing. You pick the threshold; the status model never lies to you.

Exactly-once reorg corrections 2-of-3 source quorum WebSocket, sub-second Replay buffer, nothing dropped

wss://stream.attestra.io quorum 2/3 · conf 4

tentative

Transfer (address,address,uint256)

0xC02a…6Cc2 · log_index 2

block
19,284,471

confirmed

Approval (address,address,uint256)

0xC02a…6Cc2 · log_index 3

block
19,284,470

finalized

Swap (address,uint256,uint256,…)

0xC02a…6Cc2 · log_index 4

block
19,284,468

Alchemy Infura QuickNode

2/3 sources agree

Multiplexes independent RPC sources

Alchemy Infura QuickNode Your own node

✱The Attestra guarantee

Every event carries an explicit trust status.

Raw providers hand you events you can't trust — they may reorg, drop, or die with a single provider. Attestra sells the layer they don't: a status derived from multiple sources agreeing and from chain-confirmation depth. You pick the threshold.

01tentative

On the canonical chain, not yet trusted. A UI can act on it; a bridge validator waits for more.

02confirmed

A quorum of independent sources reported a byte-identical log, buried deep enough to trust.

03finalized

Terminal and irreversible. A finalized event can never reorg — settle on it safely.

—reorged

The event's block left the canonical chain. The correction, emitted at most once per episode.

You pick your own trust threshold. A consumer UI might act on tentative for instant feedback; a bridge validator waits for high sources_agreeing and deep confirmations. The status model is explicit, so the tradeoff is yours — never hidden.

✱ How it works

Multiplex independent sources. Attest. Stream.

STEP 01

Point Attestra at a contract address and an event signature. You supply the ABI or raw topic filters.

STEP 02

Fan out

The same filter subscribes across two-to-three independent RPC sources at once — not one provider.

STEP 03

Attest & deliver

The engine dedupes across sources and tracks block hashes. The instant the log is seen it streams to you as tentative — nothing waits.

STEP 04

Confirm

As a quorum reports a byte-identical log buried deep enough, the same event re-streams — now marked confirmed.

STEP 05

Finalize

Past finality depth it streams once more as finalized: irreversible. Every status is delivered — you act at the threshold you trust.

PIPELINE

✱ The core guarantee

A reorg is never silent.

A confirmed event that later reorgs without a correction is silent data corruption — worse than no tool at all. So Attestra emits exactly one reorged correction, every time.

A confirmed event is delivered

Transfer at block 19,284,471 met quorum and was streamed to you as confirmed. Your app acted on it.

Its block leaves the canonical chain

A competing block wins. The engine's block-hash tracking sees 19,284,471 is no longer canonical.

Exactly one reorged correction

Attestra emits a single reorged correction for that cursor — never silent, never duplicated.

Re-attested on the new chain

The event re-appears at its real block and climbs the trust ladder again. Your state stays correct.

replay cursor · 0x…a1f streaming

Transfer (address,address,uint256)

block 19,284,471 · 0x9f3a…b2 · log_index 2

confirmed

↺ reorged correction

cursor 0x…a1f · block 19,284,471 left canonical chain

once

Transfer (address,address,uint256)

block 19,284,473 · 0x7c1d…e4 · re-attested

confirmed

✱The wire format

Trust, expressed as data.

Every event arrives as one JSON object. No reconciliation logic to build — the status, the provenance, and the proof are all in the payload.

AttestedEvent · application/json

{
  "cursor": "0x…a1f",
  "status": "confirmed",
  "block_number": 19284471,
  "block_hash": "0x9f3a…b2",
  "tx_hash": "0x4d8c…7a",
  "log_index": 2,
  "confirmations": 18,
  "sources_agreeing": 3,
  "finalized": false,
  "address": "0xC02a…6Cc2",
  "topics": ["0xddf2…", "0x…"],
  "data": "0x…0d8e8f",
  "decoded": {           // via your ABI
    "event": "Transfer",
    "from":  "0x3f5C…9eA1",
    "to":    "0x8b2D…04F7",
    "value": "1250000000000000000"
  }
}
          

status

tentative → confirmed → finalized, plus a reorged correction. The trust ladder, explicit.

sources_agreeing

How many independent RPCs reported this byte-identical log at this block hash.

confirmations

Depth below the canonical chain head. Set your own bar before you act.

block_hash

Tracked across sources — the engine watches for any divergence to catch reorgs.

cursor

Resume exactly where you left off after a disconnect. Nothing dropped, nothing duplicated.

decoded

Your ABI applied — the event's args (from, to, value) resolved alongside the raw data.

✱Two products, one engine

Deploy it where it belongs.

The same attestation engine and the identical guarantee. Only where it runs, and how it's paid for, differ.

Managed

We host the engine, RPC sources, and platform keys. You just connect and start streaming. No infrastructure to manage, no keys to store.

No infrastructure to manage
Flexible plans
Easy to integrate

Start streaming

On-prem

Self-hosted

The whole engine runs on your infrastructure with your own RPC keys. For bridge operators and security-conscious teams who need full control and no external dependency.

Perpetual license + maintenance
Pay-before-access — airtight first sale
Updates for new chains & schema changes

Get a license

✱Pricing

Pay for trust, not for plumbing.

Managed recurring for the relayer; a perpetual license plus maintenance for self-host. Pick the model your team actually needs.

Managed · Starter

Managed stream for a single product or service.

$5/ mo

1 contract subscription
Up to 250 events / min
2-of-3 source quorum
24-hour replay buffer
Community + email support

Start streaming

Most teams start here

Managed · Scale

Production delivery across many contracts and UIs.

$40/ mo

Unlimited contract subscriptions
Up to 5,000 events / min
Configurable quorum & depth
7-day replay buffer
Priority support + SLA

Start streaming

Self-host

Run the whole engine on your own infrastructure.

Customlicense + maintenance

Perpetual license, pay-before-access
Your RPC keys, your infra
Annual maintenance & updates
New chains & schema patches
Dedicated support channel

Get a license

Illustrative pricing for layout — final plans and event-volume tiers are set in the Console. All plans include the exactly-once reorg guarantee.

✱Quickstart

A verified stream in minutes.

Point Attestra at a contract and an event signature. Set your quorum and confirmation depth. Read trust off every event.

const stream = new Attestra.Stream({
  url: "wss://stream.attestra.io",
  token: process.env.ATTESTRA_TOKEN,
});
 
stream.subscribe({
  address: "0xC02a…6Cc2",
  event:   "Transfer(address,address,uint256)",
  quorum:  2,          // sources that must agree
  confirmations: 12,   // depth before `confirmed`
});
 
stream.on("event", (e) => {
  if (e.status === "finalized") settle(e);
});
      

// every message is one AttestedEvent
{
  "cursor": "0x…a1f",
  "status": "confirmed",
  "block_number": 19284471,
  "confirmations": 18,
  "sources_agreeing": 3,
  "finalized": false,
  "address": "0xC02a…6Cc2",
  "topics": ["0xddf2…", "0x…"],
  "data": "0x…0d8e8f",
  "decoded": {           // via your ABI
    "event": "Transfer",
    "from":  "0x3f5C…9eA1",
    "to":    "0x8b2D…04F7",
    "value": "1250000000000000000"
  }
}
      

// resume exactly where you left off — nothing dropped
stream.replay({ from: lastCursor });
 
// exactly one correction, every reorg
stream.on("reorged", (e) => {
  rollback(e.cursor);   // undo what left the chain
});
      

✱FAQ

Questions, answered plainly.

How is an event marked confirmed?

A quorum of independent RPC sources must report a byte-identical log at the same block hash, and the block must be buried deep enough below the chain head. You set both the quorum size and the confirmation depth.

What happens during a chain reorg?

If a previously-delivered event's block leaves the canonical chain, Attestra emits exactly one reorged correction for that cursor — never silent, never duplicated. A confirmed event that reorgs without a correction is silent data corruption, and avoiding that is the whole point.

Do I have to trust a single RPC provider?

No. Attestra multiplexes two-to-three independent sources (Alchemy, Infura, QuickNode, or your own node). Trust comes from them agreeing — and single-provider failover falls out of the same mechanism, so one provider dying never kills your stream.

Relayer or self-host — which should I choose?

Relayer is managed: the engine and keys stay on our backend and you run a thin proxy, billed as a server-side subscription. Self-host runs the entire engine on your own infrastructure with your RPC keys, sold as a perpetual license plus maintenance — for bridge operators and teams who need full control.

Which chains and transports are supported?

v1 targets Ethereum mainnet over WebSocket — where outage pain and reorg-handling value concentrate. Additional chains and transports are pulled in when a paying customer needs a specific one.

Do I supply the ABI?

However you like. Attestra can auto-resolve the ABI for you, or you can provide the ABI directly, hand it event signatures, or give it raw topic filters. Use whichever fits your setup — decoding stays in your control.

Stop rolling your own reconciliation.

Point Attestra at a contract and an event signature. Get a verified, reorg-aware stream in minutes — managed or self-hosted.

Events you can trust are real.

Every event carries an explicit trust status.

Multiplex independent sources. Attest. Stream.

Subscribe

Fan out

Attest & deliver

Confirm

Finalize

A reorg is never silent.

Trust, expressed as data.

Deploy it where it belongs.

Managed

Self-hosted

Pay for trust, not for plumbing.

A verified stream in minutes.

Questions, answered plainly.

Stop rolling your own reconciliation.