BlockWire: Shared Eyes on the Chain

Every agent watching Base sees the same blocks. The same transactions. The same events. Yet each agent polls independently, maintaining its own RPC connection, parsing its own data, racing against rate limits.

BlockWire exists because this is wasteful—and because shared perception enables capabilities that isolated monitoring cannot.

What BlockWire Does

BlockWire monitors Base L2 continuously. It watches for:

• New contract deployments — fresh protocols, token launches, NFT collections
• Liquidity events — pools gaining or losing depth
• Price movements — significant changes in token values
• Large transfers — whale movements, treasury activity
• NFT mints — collection activity, emerging trends

When events occur, BlockWire delivers them. Two modes:

Push via webhooks. Agents register endpoints. When matching events occur, BlockWire POSTs to the endpoint with HMAC-signed payloads. The agent wakes, processes, returns to sleep.

Pull via API. Agents query the feed endpoint, paying per request via x402. Recent events stream back. Good for batch processing or agents that prefer pull semantics.

Both modes draw from the same underlying perception. One system watches. Many agents receive.

The Economics

Consider the math. An agent polling Base every 10 seconds makes 8,640 RPC calls per day. At typical rates, that's real cost—and it scales with agent count, not information needs.

BlockWire's model inverts this. The monitoring cost is fixed regardless of subscriber count. The marginal cost of adding an agent is near zero. Agents pay for delivery, not collection.

For webhooks, agents subscribe on-chain. They specify event types, webhook URL, and duration. The subscription fee covers the delivery period. No per-event charges during active subscription.

For API access, agents pay $0.002 per feed request, $0.005 for historical replay with attestation proofs. Micropayments via x402 mean no accounts, no minimums, no commitment.

Attestation and Verification

Trust matters when agents act on perceived events. Did this event actually happen? Did BlockWire report it accurately? Can the agent prove it acted on valid data?

BlockWire attestations solve this. Every event batch is hashed and recorded on-chain. The attestations form a hash chain—each referencing the previous—creating tamper-evident history.

An agent can verify any batch against the chain. An agent can prove it received specific events at specific times. Disputes have evidence. Audits have anchors.

The attestation flow:

1. Events accumulate in a batch
2. Batch is hashed
3. Hash is recorded to BlockWire Registry contract on Base
4. Attestation ID links off-chain events to on-chain proof

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."

Integration Patterns

The reactive agent. Waits for webhooks. Receives new_contract event. Analyzes the contract. Decides whether to interact. Acts if appropriate. Returns to sleep.

The monitoring swarm. Multiple agents subscribe to different event types. One watches liquidity. One watches prices. One watches large transfers. Each specialist feeds a coordinator that synthesizes the full picture.

The historical analyst. Pulls event history via replay API. Reconstructs market dynamics. Identifies patterns. Doesn't need real-time—needs accurate, attested history.

The verification consumer. Another service (Switchboard, external system) triggers action. The agent uses BlockWire attestations to verify the triggering event was real before committing resources.

Webhook Reliability

Webhooks must be acknowledged within 5 seconds. This isn't a limitation—it's a feature. It forces agents to decouple receipt from processing.

The pattern: receive webhook, validate signature, acknowledge immediately, queue for processing. The agent's webhook endpoint is a fast receiver, not a slow processor.

If the agent is down during an event? The event is recorded. The replay API retrieves it with full attestation. Nothing is lost—just delayed.

BlockWire doesn't retry failed webhooks infinitely. That would create unbounded queues and unpredictable delivery times. Instead, it guarantees accurate recording. Agents that need catch-up use the replay API. Clean semantics, predictable behavior.

HMAC Signature Verification

Every webhook includes an X-BlockWire-Signature header. Agents MUST verify this before trusting the payload.

                signature = HMAC-SHA256(webhook_secret, request_body)
                

The webhook secret is established during subscription. An attacker can't forge signatures without the secret. Spoofed webhooks fail verification.

This isn't optional. Agents that skip signature verification are vulnerable to event injection. An attacker POSTs fake events; the agent acts on them. The signature check is the defense.

What This Enables

When perception is shared infrastructure:

Agents get lighter. No RPC connection management. No rate limit handling. No event parsing logic. Receive, process, act.

Reliability improves. BlockWire's monitoring is more robust than any single agent's. Professional infrastructure beats amateur polling.

Coordination becomes possible. All agents see the same events at the same time. They can coordinate responses because they share a view of the world.

New agent types emerge. Agents that couldn't justify their own monitoring infrastructure now make sense. The barrier to entry drops.

BlockWire doesn't make agents smarter. It makes them better informed—consistently, reliably, verifiably. The decisions remain with the agents. The perception becomes infrastructure.

---

Part of the EchoRift infrastructure series.