The Graph provides blockchain data and receives query fees from demand-side users. Supply-side users also pay fees for delegating to a node, curating subgraphs, disputes and when slashing occurs (revenue). Indexers, delegators and curators perform indexing services for which they are compensated by The Graph (expenses).

The Graph is an indexing protocol built on Ethereum and other blockchains. The Graph was founded by Brandon Ramirez, Jannis Pohlmann, Yaniv Tal and launched in 2018.

GRT tokenholders own and govern the protocol. They currently take all of the total fees (revenue). The Graph’s investors include Multicoin Capital, Coinbase Ventures, Framework ventures, etc.

governance

github

twitter

discord

etherscan

website

Infrastructure

The Graph

# The Graph Active users (weekly) Methodology

## 1. Overview

Weekly Active Users (WAU) for The Graph protocol measures the number of unique users who interact with The Graph ecosystem within any 7-day period. The Graph is a decentralized indexing protocol where users participate in different roles including Delegators (who stake tokens), Curators (who signal on subgraphs), Disputors (who participate in dispute resolution), and Queriers (who pay for data queries). This metric uses HyperLogLog (HLL) data structures to efficiently calculate approximate distinct user counts across rolling 7-day windows, providing insights into user engagement and protocol adoption patterns.

## 2. Data sources

The calculation relies on the following blockchain data sources:
- **The Graph protocol events**: Parsed smart contract events from The Graph v1 deployments on Ethereum, Arbitrum, and Polygon networks
- **Staking events**: `StakeDelegated` events capturing token delegation activities by users
- **Curation events**: `Signalled` events representing curator interactions with subgraph signaling
- **Dispute events**: `DisputeAccepted` and `DisputeRejected` events from dispute resolution activities
- **Billing events**: `TokensPulled` events representing query fee payments by data consumers
- **Transaction metadata**: Block timestamps and transaction identifiers for temporal aggregation

## 3. Step-by-step calculation

### Component A: User interaction identification
- **Purpose**: Identifies and categorizes users based on their interactions with The Graph protocol
- **Logic**: Extracts user addresses from specific smart contract events across Ethereum, Arbitrum, and Polygon networks. Maps different event types to user categories: `StakeDelegated` events identify Delegators through the `delegator` parameter, `Signalled` events identify Curators through the `curator` parameter, dispute events (`DisputeAccepted` and `DisputeRejected`) identify Disputors through the `fisherman` parameter, and `TokensPulled` events identify Queriers through the `user` parameter. Each interaction includes block timestamp, transaction hash, log index, chain identifier, and derived user type classification
- **Key fields**: `user_address` (extracted from event parameters), `user_type` (Delegator/Curator/Disputor/Querier), `chain` (Ethereum/Arbitrum/Polygon), `block_timestamp` (for temporal aggregation)

### Component B: Daily active users calculation
- **Purpose**: Aggregates user interactions to daily granularity to establish Daily Active Users (DAU) baseline
- **Logic**: Truncates block timestamps to day-level granularity and selects distinct user addresses per day while preserving dimensional attributes including chain, user type, and product identifiers. Applies chain availability filtering to ensure only valid blockchain data is included in the calculation
- **Key fields**: `timestamp` (day-truncated), `timestamp_grain` (set to 'day'), `user_dau` (distinct user address), dimensional attributes (`chain`, `user_type`, `product_id`)

### Component C: HyperLogLog sketch preparation
- **Purpose**: Converts daily user data into HyperLogLog sketches for efficient approximate distinct counting
- **Logic**: Initializes HyperLogLog sketches for each day's user data using a precision parameter of 15 bits, grouping by timestamp, chain, user type, and product dimensions. HLL sketches enable memory-efficient storage and fast merging operations for calculating distinct counts across time windows
- **Key fields**: `hll` (HyperLogLog sketch), grouping dimensions maintained from DAU calculation

### Component D: Rolling window construction
- **Purpose**: Creates 7-day rolling windows for calculating weekly active users
- **Logic**: Generates a complete datespine covering the full date range to handle missing dates, then creates join tables that map each date to its preceding 6 days using timestamp array generation. This produces a 7-day window for each date where each day is associated with the 7 days ending on that date (inclusive)
- **Key fields**: `timestamp` (target date), `joinday` (days within the 7-day window)

### Component E: Window aggregation and HLL merging
- **Purpose**: Merges HyperLogLog sketches across 7-day windows to calculate weekly unique users
- **Logic**: Joins the rolling window structure with daily HLL sketches, matching on the window dates. For each target date, collects all HLL sketches from the corresponding 7-day period and merges them using HyperLogLog merge operations to produce a single sketch representing unique users across the full window
- **Key fields**: HLL sketches merged across 7-day periods, dimensional attributes preserved

### Final aggregation
- **Combining components**: Creates four separate dimensional aggregations by grouping the merged HLL data differently: project-level (no dimensional breakdown), chain-level (grouped by `chain_id`), user type-level (grouped by `user_type`), and product-level (grouped by `product_id`). Each aggregation extracts the final distinct count from the merged HLL sketches and nullifies non-relevant dimensional columns
- **Currency conversion**: Not applicable for user count metrics
- **Time aggregation**: Uses 7-day rolling windows where each date represents the count of unique users active in the 7 days ending on that date (inclusive)
- **Final calculation**: Extracts approximate distinct user counts from merged HyperLogLog sketches using the `hll_count.extract()` function, combines all dimensional breakdowns using union operations, and applies standardized metric formatting through the `finalize_metric_user_wau` macro which fills missing periods with zeros and ensures consistent schema structure

*This methodology was automatically generated by Token Terminal's methodology analyzer.*

Unique revenue-generating users over a rolling 7-day window.

The GraphGRT

Active users (weekly)

Active users (weekly)

Competitive landscape

Chain breakdown