Liquidity providers deposit funds into Voltz and receive trading fees from traders (supply-side fees).

Voltz Protocol is a non-custodial Automated Market Maker (AMM) for Interest Rate Swaps deployed on Ethereum.

Voltz DAO owns and governs the protocol. They do not currently take a cut of the total trading fees paid by traders (revenue). Voltz’s investors include Framework, Fabric Ventrues etc.

github

twitter

discord

website

Derivative exchanges

Voltz

# Voltz Active users (weekly) Methodology

## 1. Overview

Weekly Active Users (WAU) measures the number of distinct users who interacted with the Voltz protocol within any 7-day rolling window. This metric answers the business question: "How many unique users are actively engaging with Voltz's derivatives trading platform on a weekly basis?" The calculation uses HyperLogLog sketches for efficient distinct user counting across rolling time windows, with breakdowns by project, blockchain network, user activity type, and product dimensions.

## 2. Data sources

The calculation relies on parsed smart contract events from Voltz protocol deployments across multiple blockchain networks:

- **Voltz V1 Ethereum events**: Parsed contract events including `Swap`, `Mint`, `Burn` from VAMM contracts, and `FullyCollateralisedSwap` events from FCM contracts
- **Voltz V1 Arbitrum events**: Parsed contract events including `Swap`, `Mint`, and `Burn` from VAMM contracts
- **Event data structure**: Each event contains user addresses, transaction timestamps, and contract interaction details that identify user activity patterns
- **Blockchain transaction metadata**: Block timestamps and transaction hashes for temporal ordering and deduplication

## 3. Step-by-step calculation

### Component A: User activity extraction
- **Purpose**: Identifies and classifies all user interactions with Voltz protocol contracts
- **Logic**: Extracts user addresses from parsed Voltz smart contract events across Ethereum and Arbitrum networks. `Swap` events identify traders through the `recipient` field on Arbitrum and Ethereum VAMM contracts. `Mint` events identify depositors/liquidity providers through the `owner` field. `Burn` events identify withdrawers through the `owner` field. `FullyCollateralisedSwap` events on Ethereum identify traders through the `trader` field. Each user address is tagged with their activity type (Trader, Depositor, Withdrawer) and associated metadata including blockchain network, market sector (derivatives), and business segment (perpetual)
- **Key fields**: `user_address` (the active user), `block_timestamp` (interaction time), `chain` (network identifier), `user_type` (activity classification), `transaction_hash` (deduplication key)

### Component B: Daily active user aggregation  
- **Purpose**: Aggregates user activity into daily distinct user counts while preserving dimensional breakdowns
- **Logic**: Groups extracted user addresses by day using timestamp truncation to the day level. Creates distinct user sets for each combination of date, blockchain network, user type, market sector, business segment, and product. Applies chain availability filters to ensure data quality and consistency across different network deployments. Maintains dimensional granularity needed for downstream multi-level breakdowns
- **Key fields**: `timestamp` (daily boundary), `user_dau` (distinct user address), `chain` (network), `user_type` (activity classification), `product_id` (product dimension)

### Component C: HyperLogLog sketch creation
- **Purpose**: Converts daily user sets into efficient probabilistic data structures for distinct counting across time windows  
- **Logic**: Initializes HyperLogLog sketches from daily active user sets using a precision parameter of 15 bits for accuracy-memory tradeoff. Groups data by timestamp, chain, user type, and product dimensions to create sketches that can be efficiently merged across time periods. HyperLogLog enables approximate distinct counting with minimal memory usage, essential for rolling window calculations over large user sets
- **Key fields**: `hll` (HyperLogLog sketch), `timestamp` (daily boundary), dimensional grouping fields

### Component D: Rolling window construction
- **Purpose**: Creates complete 7-day rolling windows for each date without gaps in the time series
- **Logic**: Generates a complete datespine covering the full date range from earliest user activity to present day minus one day. For each date in the datespine, creates joins to the previous 6 days plus the current day to form complete 7-day windows. Uses timestamp arithmetic to generate arrays of join dates, ensuring every day has a complete 7-day lookback window even if some days lack user activity. Joins the window framework with daily HyperLogLog sketches to populate user data for each window
- **Key fields**: `timestamp` (window end date), `joinday` (individual days within window), `hll` (user sketch for each day)

### Component E: Multi-dimensional WAU calculation
- **Purpose**: Calculates Weekly Active Users across different dimensional breakdowns for comprehensive analytics
- **Logic**: Merges HyperLogLog sketches across each 7-day window and extracts distinct user counts to generate WAU values. Creates separate calculations for four dimensional levels: project-level WAU (all users regardless of chain/type/product), chain-level WAU (users by blockchain network), user-type-level WAU (users by activity classification), and product-level WAU (users by product). Each breakdown groups by relevant dimensions while nullifying others, then applies HyperLogLog merge and extract operations to get final distinct counts
- **Key fields**: `user_wau` (weekly active user count), `dimensions` (breakdown type), dimension-specific fields (`chain_id`, `user_type`, `product_id`)

### Final aggregation
- **Combining components**: Unions all dimensional breakdown results (project, chain, user type, product) into a single comprehensive dataset with appropriate null handling for non-relevant dimensions in each breakdown
- **Currency conversion**: Not applicable for this user count metric
- **Time aggregation**: Uses 7-day rolling windows with daily granularity, where each day represents the WAU for the 7-day period ending on that date
- **Final calculation**: Applies standardized metric finalization including schema normalization, missing day filling with zeros, data quality tags, and incremental processing logic with appropriate lookback periods for data freshness

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

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

Voltz

Active users (weekly)

Active users (weekly)

Competitive landscape

Chain breakdown