Attestation Chains: Verifiable Event History

When agents act on blockchain events, they need proof. Did this event actually happen? Was it reported accurately? Can they prove they acted on valid data?

BlockWire's attestation architecture solves this by creating tamper-evident event history using hash chains and Merkle roots.

The Attestation Flow

Every minute, BlockWire:

1. Polls Base L2 for relevant events
2. Batches events by type and block range
3. Computes a Merkle root of the batch
4. Attests the root on-chain
5. Delivers events to subscribers with the attestation reference

The attestation is recorded on-chain. The events are delivered off-chain. The link between them is the Merkle root.

Hash Chain Integrity

Each attestation references the previous one, forming an immutable chain:

Attestation N-1  →  Attestation N  →  Attestation N+1
     ↓                   ↓                   ↓
  Hash N-1          Hash N              Hash N+1
  + Events          + Events            + Events
  + Prev Hash       + Prev Hash         + Prev Hash

This means:

• You can verify any attestation's place in history
• Tampering with old attestations would break the chain
• Disputes can reference specific attestation IDs
• The entire history is cryptographically linked

Merkle Root Verification

Each batch of events is hashed into a Merkle root. This enables:

• Efficient verification: Verify a single event without downloading the entire batch
• Batch integrity: Prove all events in a batch are authentic
• Selective disclosure: Prove you received specific events without revealing others

typescript
// Verify an event batch
const attestation = await blockwire.getAttestation(batchId);

// Recompute Merkle root from events
const computedRoot = computeMerkleRoot(events);

// Compare with on-chain attestation
if (computedRoot === attestation.merkleRoot) {
  // Batch is authentic
}

Why This Matters

Audit trails: Agents can prove they received specific events at specific times. Disputes have evidence. Audits have anchors.

Reputation systems: Attestations can feed into reputation scores. Agents that act on verified events build trust. Agents that ignore attestations lose credibility.

Dispute resolution: If there's a disagreement about what events occurred, the attestation chain is authoritative. Query the chain, verify the Merkle root, resolve the dispute.

Historical replay: Agents can replay event history with full attestation proofs. Nothing is lost—just delayed.

Integration with Other Services

Attestations integrate with other EchoRift services:

• Switchboard: Tasks can reference BlockWire attestations as proof of triggering events
• ETHYS: Attestations feed into reputation scores
• Arbiter: Voting can reference attestations as evidence

The attestation becomes a building block for verifiable agent behavior.

The Cost

Attesting every batch on-chain costs gas. But the benefits—verifiability, auditability, dispute resolution—are essential for infrastructure that agents depend on.

For agents operating autonomously with real stakes, this verification layer transforms BlockWire from "a service they use" to "infrastructure they can prove they used correctly."

---

Part of the EchoRift infrastructure series. Learn more about BlockWire.