Web3 Discovery and On-Chain Web3 Insight: Finding Hidden Signals in Indexed Blockchain Data

Web3 teams really hit the jackpot when they can catch on-chain signals before everyone else does--like when sequencer revenues shoot up on a fresh L2, blob fees start squeezing your rollup’s unit economics, or restaking risks go from just a theory to something you have to deal with. This guide is here to help decision-makers tap into modern, indexed blockchain data, making it easy to pull out those signals and plug them right into your product and strategy.

Discover Hidden Signals in On-Chain Data: A Hands-On Playbook

Overview

This hands-on playbook is designed for decision-makers looking to tap into the hidden signals within on-chain data. It's packed with insights and practical advice, covering everything from Substreams to EigenLayer restaking and ERC-4337. We’ll dive into specific queries, architectures, and what the landscape might look like in 2025-2026.

Table of Contents

1. Getting Started
2. Understanding On-Chain Data
3. Exploring the Tools
   • Substreams
   • ClickHouse
   • Dune
   • BigQuery
   • Blob Markets
   • Superchain Metrics
   • MEV Orderflow Auctions
   • EigenLayer Restaking
4. Practical Applications
5. Looking Ahead: 2025-2026
6. Conclusion

Getting Started

To kick things off, let’s get familiar with the basics of on-chain data. Whether you’re new to the topic or looking to enhance your existing knowledge, we’ve got you covered.

Understanding On-Chain Data

On-chain data is a treasure trove of information. It’s all about the transactions that occur on the blockchain, and it can reveal insights into market trends, user behavior, and network performance. Understanding this data is crucial for making informed decisions in the blockchain space.

Exploring the Tools

Now, let’s delve into some powerful tools that can help you uncover those hidden signals.

Substreams

With Substreams, you can build custom streaming pipelines that handle on-chain data with ease. They allow you to focus on the specific data that matters to you without getting overwhelmed by the noise.

ClickHouse

ClickHouse is a fast open-source columnar database management system that can handle large volumes of data. It’s perfect for analyzing on-chain data and generating reports in real-time.

Dune

Dune is a user-friendly platform for analyzing blockchain data. It allows you to create custom SQL queries and share your findings with the community. Plus, it’s a great way to see what others are discovering!

BigQuery

Google BigQuery is another powerful tool for data analysis. It’s designed for handling massive datasets, making it ideal for on-chain data analysis. You can run complex queries and get results quickly.

Blob Markets

Blob markets are becoming increasingly relevant as the blockchain ecosystem evolves. They provide a way to buy and sell data storage and retrieval services, unlocking new opportunities for on-chain data analysis.

Superchain Metrics

Superchain metrics can help you measure the performance and activity of your blockchain networks. These metrics provide valuable insights for decision-making and can guide your strategy moving forward.

MEV Orderflow Auctions

Understanding MEV (Miner Extractable Value) orderflow auctions is key for those looking to optimize transaction routing and maximize profitability. It’s a complex topic, but mastering it can give you a significant edge.

EigenLayer Restaking

EigenLayer restaking is a fascinating concept. It allows users to leverage their existing stake to support new protocols without putting up additional capital. This can drive innovation and create new opportunities in the ecosystem.

Practical Applications

Now that we’ve explored the tools, let’s look at some practical applications. Here are a few ideas on how to utilize these tools effectively:

1. Market Analysis: Use BigQuery and ClickHouse to analyze transaction trends over time.
2. User Insights: Leverage Dune to uncover patterns in user behavior.
3. Performance Metrics: Monitor your blockchain’s performance with Superchain metrics to identify areas for improvement.
4. Profit Optimization: Experiment with MEV orderflow auctions to find the best routes for your transactions.
5. Data Storage Solutions: Explore blob markets for efficient data management and storage.

Looking Ahead: 2025-2026

As we look toward 2025 and 2026, the on-chain data landscape is set to evolve dramatically. Here are some trends to keep an eye on:

• Increased Integration: More projects will integrate with existing tools, making it easier to access and analyze on-chain data.
• AI and Machine Learning: Expect to see AI-driven analytics tools that can predict market trends based on on-chain data.
• Enhanced Privacy Solutions: As on-chain activity grows, there will be a push for solutions that allow users to maintain their privacy while still providing valuable data insights.

Conclusion

In a nutshell, leveraging on-chain data can give you a significant advantage in the blockchain space. By using the tools and strategies outlined in this playbook, you’ll be better equipped to uncover hidden signals and make informed decisions. The future looks bright for those who dive into on-chain data--so get started today!

---

Why “discovery” now looks different

In 2025-2026, we saw three major shifts that changed the game for what “on-chain insight” needs to keep an eye on:

• Rollups and Data Availability (DA) layers really took off this year! With EIP‑4844 blobs now being the go-to for Layer 2s, Ethereum’s capacity for these blobs has increased--thanks to Pectra, EIP‑7691, and later BPO forks. Plus, DA alternatives like EigenDA and Celestia are finally making their mark with impressive throughput. If you’re not keeping an eye on blob supply, the mix of DA, and finality windows, you might be missing out. (eips.ethereum.org)
• The OP Stack’s Superchain has really streamlined usage and boosted revenue. Base was the standout in H1 2025 in terms of transactions and sequencer revenue, meaning if you're discovering a chain, you're basically discovering the Superchain too! (messari.io)
• Order flow and wallet user experience have definitely leveled up: Flashbots MEV‑Share has turned user order flow into trackable refunds, and the AA (ERC‑4337) has set a standard for smart accounts across v0.6 and v0.7 EntryPoints that you can index directly. (docs.flashbots.net)

The idea here is to create a discovery pipeline that’s clued into DA, rollups, and order flow. From there, you can connect it to alerts and your product strategies.

---

The modern on‑chain data stack (that actually scales)

Here’s the stack we use for clients who need quick discovery and a reliable audit trail.

1) Lossless ingest and replay with Substreams/Firehose

• Firehose lets you stream full block data with reorg-safe chunking and file-oriented backfill, all thanks to The Graph’s StreamingFast team. It's honestly the simplest way to keep “truth” and “speed” in check without having to reindex everything every time there's a fork. Check it out here: (firehose.streamingfast.io).
• With Substreams modules, you can set up transforms just once and then send the output to multiple places like SQL, Kafka, or Parquet. Recent updates have brought in more chains, enhanced Base performance, and introduced Foundational Store primitives for better consistency. Dive into the details here: (forum.thegraph.com).

2) Low‑latency analytics with ClickHouse + Kafka

• When it comes to time-series blockchain analytics, ClickHouse is still the top choice for an open columnar engine. If you’re looking for exactly-once semantics (thanks to KeeperMap) and reliable backpressure, definitely check out the Kafka engine or Kafka Connect Sink. You can get all the details right here.
• Substreams:SQL is pretty cool because it maps protobuf to relational tables, allowing for inserts, updates, and upserts while also managing reorgs (just a tiny delay with ClickHouse). Plus, you can throw dbt into the sink for continuous materializations. Learn more about it here.
• You can expect some seriously fast scans--10 to 100 times quicker than row stores! Teams are seeing speeds of tens of millions of rows per second for their interactive dashboards. Check out the full scoop here.

3) Indexed APIs for speed to value

Sometimes You Don’t Need Custom Indexing Yet:

• You might be fine with the default settings that your database offers.
• It's possible your dataset is small enough that search speeds are quick without any tweaks.
• If your application isn’t heavily reliant on search functionality just yet, sticking with what’s there is often sufficient.
• Custom indexing can add complexity, and if you don’t really need it now, it might be better to keep things simple.

In short, take a moment to think about whether you truly need to dive into custom indexing right away. Sometimes simplicity is the way to go!

• Dune’s API gives you access to over 500TB of curated on-chain data, along with serverless querying, dbt connectors, and BI integrations. It's ideal for quickly prototyping KPIs and setting up alerts--no heavy infrastructure required. (dune.com)
• Covalent GoldRush serves up structured REST/WS for 100+ chains, offering decoded logs, pricing data, and real-time streams. It’s super useful for product teams looking to get “working data” up and running in just a few hours. (goldrush.dev)
• If you’re into reproducible analysis and machine learning, Google BigQuery’s public datasets (think Ethereum, Polygon, and more) are still top-notch. Plus, OP Labs’ Superchain data is available through BigQuery via community mirrors. (cloud.google.com)

4) Label enrichment (without paying a fortune)

• The Etherscan API v2 has rolled out some cool features like “Nametags”/labels and a unified multichain access. This is pretty handy for labeling exchanges and bridges, plus it helps tie together basic entities. You can use it to enhance your top counterparties in your data lake. Check out the details here: (docs.etherscan.io)

5) Finality and data retention you can explain to Finance

• Right now, on Ethereum, practical finality is sitting at about 15 minutes (which is two epochs). So, when you're planning alerts and figuring out revenue recognition, keep this in mind instead of focusing on per-slot proposals. The research on SSF is still in progress, but for your immediate SLOs, you should work with the current finality. (ethereum.org)
• Just a heads up: blobs only stick around for about 18 days. If you’re counting on them for audits or analytics, you'll need to offload your content and proofs yourself. Think of it like Blobscan: you'll want to set up an indexer, an API, and multi-provider blob storage. (migalabs.io)

---

What to discover: the hidden signals that move strategy

A) Data availability share: who’s writing where?

• When it comes to Ethereum’s DA share, Base usually leads the pack as the biggest contributor. EigenDA and Celestia also play a significant role in boosting overall throughput. You’ll often see Mantle and Eclipse among the top contributors as well. Keep an eye on the daily share and concentration; it’s a good way to gauge the supply side of blockspace, plus it’s a leading indicator for users and fees. (l2beat.com)

Why It Matters

The costs associated with data availability (DA) and throughput play a big role in the margins of layer 2 solutions. If your product relies on the gas economics of a blockchain, keep an eye on the increasing blob capacity. For instance, Pectra's target of 6 with a max of 9, followed by BPO1 aiming for 10 and a max of 15, could really impact your unit costs. It's a good idea to connect your pricing experiments with the blob fee structures. Check out more details on l2beat.com.

B) Superchain growth and sequencer revenues

• In the first half of 2025, OP Superchain managed to process a whopping 2.47 billion transactions! Leading the pack was Base, with an impressive 1.57 billion transactions and a juicy $42.4 million in sequencer revenue--accounting for 87.2% of the entire OP-chain group. This is what you call “product-market-chain fit.” Keep an eye on net flows, usage, and how revenue sharing evolves to get ahead of any incentive changes and potential listing opportunities. (messari.io)

C) MEV orderflow auctions (user refunds as a KPI)

• Flashbots MEV‑Share allows wallets and apps to auction off order flow while automatically refunding users. You can index its event stream using the BigQuery dataset from Eden to measure how much value your users are getting back and identify which partners are giving the best refunds. Check it out here: (docs.flashbots.net)

D) Restaking: from TVL hype to enforceable risk

• In 2025, EigenLayer kicked off mainnet slashing, shifting the risk focus from documentation to code. What you want to discover here is which AVSs are up and running, which operators have opted in, and how the slashing conditions relate to your counterparty risk. Be sure to keep an eye on TVL and the count of AVSs, but also make sure you’re tracking operator/AVS opt-ins and slashing events. Check out more details here!

E) Account Abstraction: measurable UX lift, concrete event trail

• EntryPoint v0.6 address: 0x5FF1…2789; v0.7: 0x0000…7032 spread out over various chains. To get a clear picture of adoption, keep an eye on the UserOperationEvent across these chains. You can break it down by Paymaster to figure out where that “gasless” user experience is helping with retention. (alchemy.com)

---

Concrete examples you can run this week

1) Blob‑era cost pressure: alert on capacity changes and blob fees

Blob supply and fee dynamics have a direct impact on L2 posting costs. This can affect your app’s profit margins, especially if you’re covering transaction fees for users.

• Keep an eye on Ethereum's DA throughput and capacity usage every day. You’ll want to set up alerts for when capacity usage goes above 60% or if there are any changes to the target or max blobs via the “BPO” governance. For the latest parameters and updates, check out L2BEAT’s Ethereum DA page. (l2beat.com)
• Consider storing blob contents on your own. You can design it similarly to Blobscan: start by grabbing consensus and execution metadata, save the content to a multi-provider storage solution (like GCS or S3), and maintain an index that’s keyed by a versioned hash. (docs.blobscan.com)

Pseudocode for a Substreams‑to‑ClickHouse Sink that Flags High‑Usage Days

Here's a straightforward approach to flag high-usage days using a Substreams-to-ClickHouse sink. This pseudocode outlines the key steps:

// Define the threshold for high usage
HIGH_USAGE_THRESHOLD = 1000

// Stream from Substreams
stream usageData = getUsageData()

// Process the stream
for each day in usageData:
    // Calculate total usage for the day
    totalUsage = sum(day.usage)

    // Check if the total usage exceeds the threshold
    if totalUsage > HIGH_USAGE_THRESHOLD:
        // Flag the day as high usage
        flagHighUsageDay(day)

        // Store the flagged day in ClickHouse
        storeInClickHouse(day, totalUsage)

Key Components:

• Usage Threshold: Set the threshold for what counts as "high usage."
• Fetching Data: Use getUsageData() to pull in daily usage stats.
• Processing Loop: Go through each day’s data to compute total usage and flag accordingly.
• Storing Results: If a day is marked as high usage, save that info in ClickHouse for later analysis.

Feel free to tweak the threshold or processing logic as needed to better fit your requirements!

# substreams.yaml
sink:
  module: map_blobs
  type: sf.substreams.sink.sql.v1.Service
  config:
    engine: clickhouse
    dbt_config:
      files: ./dbt
      run_interval_seconds: 300
      enabled: true

Next up, we’ve got a dbt model that calculates the daily capacity used. If this goes over a certain threshold, it’ll trigger an alert flag that we can send straight to PagerDuty or Slack.

2) Measure MEV‑Share refunds per user cohort (BigQuery)

-- Requires BigQuery access to eden-data-public.flashbots.mev_share
-- MEV refunds by day and top orderflow providers
SELECT
  DATE(block_timestamp) AS day,
  orderflow_provider,
  COUNT(*) AS bundles,
  SUM(refund_amount_eth) AS eth_refunded
FROM `eden-data-public.flashbots.mev_share`
WHERE block_timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY)
GROUP BY 1,2
ORDER BY day DESC, eth_refunded DESC;

You’ve got yourself a solid KPI to work with: “refunds per active wallet.” This one can really help you see how it ties into retention rates. Plus, the dataset refreshes roughly every 15 minutes. Check it out here: (docs.edennetwork.io).

3) Multi‑chain AA adoption: count UserOperationEvent across chains

The UserOperationEvent topic (v0.6) is 0x49628f…1419f. You can check out how many events are happening each day on mainnet, Base, OP, and Polygon by diving into public datasets or even using your own ClickHouse lake. Here’s how you can do it:

-- Ethereum mainnet in BigQuery
SELECT
  DATE(block_timestamp) AS day,
  COUNT(1) AS userops
FROM `bigquery-public-data.crypto_ethereum.logs`
WHERE topics[SAFE_OFFSET(0)] = '0x49628fd1471006c1482da88028e9ce4dbb080b815c9b0344d39e5a8e6ec1419f'
GROUP BY 1
ORDER BY day DESC
LIMIT 30;

Do the same for crypto_optimism.logs, crypto_polygon.logs, and so on, then bring it all together by day to see how the adoption stacks up. If you're running your own infrastructure, you’ll find that the same filter runs super fast in ClickHouse with JSONEachRow turning into materialized columns on topics.0. You can check out the topic reference on public explorers, which aligns nicely with the v0.6 EntryPoint. For more info, head over to (cloud.google.com).

4) Enrich counterparties with Etherscan Nametags (labels)

When a wallet starts interacting a lot with certain destinations, it’s helpful to add some lightweight entity context:

curl "https://api.etherscan.io/v2/api?module=account&action=nametags&address=0x...&chainid=1&apikey=$KEY"

You’ll receive labels such as “Coinbase, Exchange” along with metadata that lets you easily link back to your fact tables--no need to fork out for an expensive label subscription. Just stick with API v2 from now on. (docs.etherscan.io)

5) Real‑time pipeline: Substreams → Kafka → ClickHouse

• We have substreams that connect to Kafka topics for each module, like erc20_transfers and blobs_meta.
• The ClickHouse Kafka engine tables take in data and merge it into MergeTree targets. We should keep the "reorg watermark" in mind and only promote rows that are older than N blocks or epochs.
• The Kafka Connect Sink offers exactly-once processing. It's a good idea to set batch sizes to at least 1000 and use JSON array batching to help cut down on CPU and IO usage. (docs-content.clickhouse.tech)

---

“What changed” checklists you can turn into dashboards

DA and blob market checklist

• Check out the percentage of Ethereum's DA capacity that's being used compared to the target/max blobs. You can also keep an eye on any parameter changes (like Pectra and BPO1). (l2beat.com)
• Take a look at the biggest DA posters each day for Ethereum, EigenDA, and Celestia. It's interesting to see how Base, Mantle, and Eclipse hold the top spots almost daily. (l2beat.com)
• Don’t forget to check your archive for blob retention coverage. Make sure you’re looking for at least 18 days of coverage plus some redundancy. (migalabs.io)

Superchain fundamentals

• Tx share and sequencer revenue for each OP-chain; usually, Base takes the lead in both categories--keep an eye out for any shifts that might come from new incentives or features like Flashblocks preconfirmations (around 200ms). Until they're finalized, think of preconfirmations as a soft state. (messari.io)

MEV and orderflow

• MEV-Share refunds for each Monthly Active User (MAU), the leading orderflow partners, and the percentage of transaction volume that goes through protected routes. (docs.flashbots.net)

Restaking and AVS risk

• AVSs have got a lot going on right now, with things happening live versus in development, operator opt-ins, and the whole business of slashing events, both in terms of count and value. Since April 2025, slashing has been live on mainnet, which means we’re dealing with some serious risks here. (coindesk.com)

AA adoption

• UserOperationEvent by chain and day, Paymaster share, and the mix of EntryPoint versions (v0.6 vs. v0.7). Make sure to stick to the canonical addresses: for v0.6, it's 0x5FF1…2789; and for v0.7, you’ll be looking at 0x0000…7032. (alchemy.com)

---

Emerging best practices (2026‑ready)

1. Think about finality, not just speed

• When it comes to Ethereum, design alerts and user-visible states based on that ~15-minute finality window. It’s cool to use “soft” indicators like Flashblocks preconfirmations to enhance the user experience, but hold off on booking any revenue until that canonical window has passed. SSF might speed things up down the line, so make sure to keep a feature flag handy. (ethereum.org)

2) Treat Blobs as Temporary; Archive Like Crazy

• Make sure to replicate both the blob content and metadata to your own storage using keyed versioned hashes. The reference architecture from Blobscan (that’s the indexer, API, and multi-provider blob storage combo) is a great model to follow. Check it out here: (docs.blobscan.com)

3) Keep compute and storage separate in your lakehouse

• For handling data, consider using Substreams with Kafka for transport, ClickHouse for speedy OLAP tasks, and store your cold history in Parquet. Use dbt to create your models, and for those rare occasions when you really need transactional joins, a lightweight Postgres can do the trick. Plus, Substreams:SQL now comes with dbt hooks to keep your models up-to-date. Check out the details here.

1. Go for open, testable interfaces for order flow and MEV

• MEV-Share's open specifications and public datasets allow for easy auditing, which is super important. Steer clear of those black-box "private relays" because you won’t be able to measure user refunds or fairness. Check out more details here.

1. Make label enrichment explainable

• Leverage Etherscan API v2 Nametags as a starting point and keep a log of the “why” (think source, timestamp, label slug). This approach is way better than those unclear vendor labels when auditors come looking for some background info. (docs.etherscan.io)

1. Restaking KPIs beyond TVL

• Keep an eye on “enforceability” (are slashing conditions in effect yet?), the variety in AVS, and how concentrated the operators are. Remember, TVL is just a surface-level security measure without slashing in place. Now that slashing is live, it's time to start measuring it. (coindesk.com)

7) Account Abstraction Metrics that Correlate with Retention

• Keep an eye on the Paymaster-sponsored shares and the reasons for failures. With EntryPoint v0.7, we’re seeing a drop in gas fees and some solid improvements in validation processes. Make sure to flag any apps that are still struggling on v0.6. Check out more on this at alchemy.com.

---

Two discovery playbooks to copy

Playbook A: “Which OP‑chain should we launch on next?”

• Start by narrowing down your options based on DA costs and the blob capacity trend. Check out the Ethereum DA parameters and see how the chain fares in terms of postings. You can find more details over at l2beat.com.
• Next up, take a look at the sequencer economics. This includes transactions, how the fee revenue is shared, and any profit-sharing arrangements with the Collective. Messari’s H1 2025 report is a solid reference for this info. Dive into it on messari.io.
• Finally, let’s validate the user experience speed. If you’ve got Flashblocks-style preconfirmations up and running, measure “time-to-preconfirm” against “time-to-finalize” using your client telemetry. Make sure to document the trust vs. latency tradeoff for everyone involved. More guidance can be found in the Gelato docs.

Playbook B: “Are our gasless wallets actually moving the needle?”

• Take a look at the UserOperationEvent counts by day and Paymaster label for your top chains. Then, normalize that data by daily active wallets to create a handy “gasless adoption index.” You can check it out here: (hekla.taikoscan.io).
• Next up, see how that correlates with MEV‑Share refunds earned by those users. If you notice some significant refunds, be sure to display them in the wallet to encourage those positive behaviors. More details here: (docs.flashbots.net).
• And hey, if you’re still hanging out on v0.6, it’s time to set a goal for migrating to v0.7 by 2026. This will help streamline your operations. Don’t forget to keep an eye on the version mix in your dashboards. Check it out: (alchemy.com).

---

Implementation notes that save months

• If you can avoid it, don’t reinvent the wheel when it comes to decoders. Kick things off with GoldRush, Dune, or BigQuery for your prototypes. Once your KPIs are solid, you can move those critical paths over to Substreams or ClickHouse. Check out their guide here.
• Always partition by block number and chain ID. When you’re ready, promote to “finalized” tables using materialized views that have a configurable lag based on slots or epochs for each chain. Don’t forget to use ClickHouse TTLs to clean up those pre-finalized buffers. Get more details here.
• Keep a “reorg ledger” handy. Whenever you backfill, make sure to log the before and after block hashes for any changed heights and replay the aggregates that were affected--your auditors will be grateful! Substreams’ file-first model makes handling this much easier. You can read more on this here.
• When doing OP-stack latency experiments, make sure to label preconfirmations differently from L2 blocks. You want wallets to indicate “preconfirmed” first and then move to “finalized,” similar to how exchanges display “confirmations.” Treat it like an optimistic UI for better user experience. For more info, check out this link.

---

Looking ahead: proof‑carrying insights

The distinction between “off-chain analytics” and “on-chain guarantees” is getting a bit fuzzy:

• ZK coprocessors, like Succinct’s SP1, are game changers when it comes to proving complex computations (even those tricky L1 block ranges) and getting them verified on-chain. Plus, with proof aggregation, we can keep costs down. You can expect to see “proof-carrying metrics” shift from just a buzzword to actual contracts that manage rewards. (docs.succinct.xyz)
• If you’re into historical data, you’ll love what Axiom v2 brings to the table. It allows for verified queries over Ethereum’s history by utilizing on-chain block hash roots. This innovation opens the door to “trust-minimized leaderboards,” “verified loyalty,” and so much more. (github.com)

Build now so you can flip a switch later--transforming your dashboards into attested program logic when it counts.

---

TL;DR for decision‑makers

• Use Index with Substreams/ClickHouse to boost both speed and accuracy, and kick off a prototype using Dune/GoldRush/BigQuery to get insights faster. (docs.substreams.dev)
• Keep an eye on the important signals that drive your strategy: things like DA share and blob capacity, Superchain revenues, MEV-Share refunds, EigenLayer slashing/opt-ins, and ERC-4337 UserOps across different chains and Paymasters. (l2beat.com)
• Design for the realities of finality and retention: remember that Ethereum has about a 15-minute finality time and 18-day blob retention, and make sure these details are clear in your alerts, SLAs, and archives. (ethereum.org)

If you’re looking to weave these elements into your roadmap, 7Block Labs has got you covered. We’ve rolled out this stack across exchanges, wallets, and L2s, and we’re totally ready to transform this playbook into user-friendly dashboards and alerts that your exec team will actually find useful.