Strait indexes every asset crossing Hemi’s Bitcoin and Ethereum bridges. Three chains ingested. One unified record per transfer. Real-time, reorg-safe, queryable from day one.
# Query any tunnel transfer — Bitcoin to Hemi
tunnelTransfer(id: "a3f7...c91d") {
asset # BTC | ETH | ERC20
route # BTC_TO_HEMI
amount
status # FINALIZED
sourceTx { hash blockNumber chain }
destinationTx { hash blockNumber chain }
popProofs { bitcoinTxid bitcoinBlock }
}A complete tunnel flow involves at least three blockchain states — Bitcoin initiation, Hemi PoP anchoring, and destination minting — with different finality semantics and no shared identifier in raw form. Reconstructing a single transfer requires stateful, ordered joining across three asynchronous data sources. No existing tool does it.
Index Hemi’s EVM events just fine — but are blind to Bitcoin entirely. They show you the destination half of every tunnel transfer with no link to the Bitcoin deposit that triggered it.
Show individual transactions on individual chains. No aggregation, no streaming, no cross-chain joins, no analytics. Three tabs open is not an indexer.
Treat bridges as opaque entities. They don’t understand Hemi’s tunneling semantics, PoP anchoring, or the dual nature of BTC tunnels versus ETH tunnels.
Every team builds a partial version of the same thing in isolation. Most rely on polling and miss reorg edge cases. None expose a usable API.
The result: every team that needs canonical tunnel data is building partial versions of the same thing in isolation — and getting reorgs wrong.
Three ingesters. One join engine. A single, coherent record per transfer.
Bitcoin Node Hemi RPC Ethereum RPC
| | |
+----+----+ +----+----+ +-----+-----+
| Bitcoin | | EVM | | EVM |
|Ingester | |Ingester | | Ingester |
| (BTC) | | (Hemi) | | (ETH) |
+----+----+ +----+----+ +-----+-----+
| RawEvent | RawEvent | RawEvent
+--------------+------+-----------------------+
| mpsc channel
+----+--------+
| Join Engine | <- state machine per transfer
| (strait- | INITIATED -> ANCHORED -> FINALIZED
| join) | \-> REORGED
+----+--------+
| TunnelTransferUpdate
+-------+----------+
| strait-store | <- Postgres (sqlx)
+-------+----------+
|
+----------+-----------+
| strait-api (axum) |
| GraphQL | Webhooks |
+----------------------+
Independent ingesters poll Bitcoin (via RPC), Hemi, and Ethereum (via alloy). Each runs its own reorg-detection window. Bitcoin deposits watch custody addresses and OP_RETURN data encoding the Hemi destination. EVM ingesters decode tunnel contract events.
A stateful engine consumes all three event streams over mpsc channels. It matches related cross-chain events using the Bitcoin txid or Ethereum tx hash as the join key, and drives a per-transfer state machine from INITIATED through to FINALIZED.
Every ingester keeps a rolling block-hash window beyond its confirmation depth. On each new block, the parent hash is verified. A mismatch triggers backward walking to the fork point, a BlockReorg event, and retraction of any in-flight transfers that referenced reorged transactions.
The unified TunnelTransfer dataset is written to Postgres and served via a GraphQL API (async-graphql + axum) with cursor pagination, filters, and time-windowed aggregations. Webhooks fan out status updates in real time, signed with HMAC-SHA256.
The Graph is general-purpose EVM infrastructure that happens to support Hemi. Strait is Hemi-specific infrastructure that understands the chain’s defining feature — tunnels — natively.
| Capability | The Graph(on Hemi) | Goldsky(not on Hemi) | Custom in-house | Strait |
|---|---|---|---|---|
| Indexes Bitcoin tunnel side | ✗ | ✗ | sometimes | ✓ |
| Cross-chain join | ✗ | ✗ | sometimes | ✓ |
| Real-time webhooks | ✗ | ✓ | varies | ✓ |
| Reorg-safe by design | partial | EVM only | ✗ | ✓ |
| Hemi-specific schema | ✗ | ✗ | varies | ✓ |
| PoP proof tracking | ✗ | ✗ | ✗ | ✓ |
| Full lifecycle status | ✗ | ✗ | ✗ | ✓ |
| Available as a product | ✓ | ✗ | ✗ | ✓ |
Strait is not a better indexer in a crowded market. It is the only indexer for a category of data that every serious Hemi participant needs — and that no other system produces.
The Graph covers hundreds of chains generically. Strait covers one chain with surgical depth. That means PoP proof tracking, OP_RETURN parsing, and dual-finality reconciliation built in.
The ingestion, join, and webhook layers are written in Rust. The type system makes the state machine tractable to verify. Tokio handles I/O concurrency. No GC pauses, no missed reorgs.
Full cursor-paginated query interface. Filter by asset, route, status, amount, sender, recipient, and time window. Aggregate stats (volume, count, median finality) per time period. GraphiQL playground in development.
Sub-second delivery from chain event to your endpoint. HMAC-SHA256 signed payloads. Configurable filters on amount, address, asset, and status transition. Exponential-backoff retry with up to 5 attempts.
Every ingester maintains a rolling block-hash window. Reorgs are detected by verifying parent hashes on every new block. Affected transfers are retracted — not deleted — with a reorg_at timestamp for full auditability.
Watches tunnel custody addresses directly via Bitcoin RPC. Parses OP_RETURN data encoding the Hemi destination address. Tracks every sat from Bitcoin deposit through Hemi mint in a single joined record.
Hemi's Proof-of-Publication miners anchor Hemi finality to Bitcoin. Strait indexes every PoP submission, links it to the Hemi block range it covers, and attaches it to the relevant TunnelTransfer records.
Every raw event from all three chains is written to an append-only log before processing. If the join engine needs to restart or the schema migrates, events can be replayed from any block height.
Tunnel data is high-leverage. A small number of well-defined customer segments need it, and all of them require the same underlying joined dataset.
Know the origin of every deposited asset. Risk-stratify lending positions by capital provenance. Detect large tunnel inflows before they hit your liquidity pool.
Power Dune-equivalent dashboards on Hemi. Track TVL composition, capital flows, and route utilization across all tunnel directions from a single API.
Surface real-time tunnel status to end users. Show estimated time-to-finality for in-flight transfers. Alert on deposit confirmation without polling three chains.
Institutional BTC flow tracking with full Bitcoin-to-Hemi chain of custody. OFAC screening of tunnel participants. Reorg-aware audit logs that never delete history.
Detect large tunnel events in real time and predict downstream liquidity movements. Cross-chain arbitrage detection between tunneled and native assets.
Ecosystem reporting, TVL composition, capital flow analysis, and partner integration tracking — all from a canonical data source the whole ecosystem trusts.
Strait is infrastructure. Every app below reads the same indexed tunnel data — start with the developer docs.
The GraphQL and REST API that powers everything here — full Transfer schema, queries, contract addresses, and a self-host guide.
Read the docs →Volume, TVL, route utilization, average finality time, and flow charts — Dune-style dashboards built straight off the indexed tunnel data.
Open Analytics →HMAC-signed push notifications for transfer lifecycle events — register a URL, get notified the moment a matching transfer finalizes or fails.
Register a webhook →Use Bitcoin-anchored tunnel transfers as a settlement and collateral signal — lend against BTC bridged into Hemi, settled across chains.
Explore the idea →Tunnel indexing is the beachhead. Every component built for the wedge has a role in the platform — the architecture is a strict subset, not a throwaway.
Stop stitching together three chain explorers. Strait gives you a complete, real-time, reorg-safe view of every asset moving through Hemi — queryable in seconds.