Users deposit funds into pools, called Hypervisors, and receive a return on investment (supply-side fees) after rebalancing.

Gamma Strategies is an asset management protocol built on Ethereum and other blockchains. Gamma Strategies was founded by an anonymous team and launched in 2020.

GAMMA tokenholders own and govern the protocol. They currently take a cut of the total return on investment & total assets under management paid by liquidity providers (revenue).

github

twitter

discord

etherscan

website

Asset management

Gamma Strategies

# Gamma Strategies Average revenue per user (ARPU) Methodology

## 1. Overview

ARPU (Average Revenue Per User) measures the average daily revenue generated per active user on the Gamma Strategies protocol. This metric is calculated by dividing daily protocol revenue by daily active users (DAU). Gamma Strategies is a yield aggregation protocol that manages liquidity positions across multiple DEX platforms (Uniswap, Zyberswap, QuickSwap) on Ethereum, Arbitrum, Optimism, and Polygon networks. The protocol operates both v1 and v2 hypervisor contracts with different fee structures.

## 2. Data sources

- **User activity events**: Parsed `Deposit` and `Withdraw` events from Gamma Strategies hypervisor contracts across all supported chains and versions
- **Protocol yield events**: Parsed `Rebalance` events from v1 hypervisor contracts containing fee amount data
- **Fee configuration events**: Parsed `ZeroBurn` events that emit dynamic protocol fee rate changes for v2 hypervisors
- **Protocol fee transfers**: Token transfer logs showing fees sent to designated protocol fee wallet addresses from v2 hypervisors
- **Hypervisor metadata**: Parsed `HypeAdded` events for hypervisor registration and version classification based on block number splits
- **Token metadata**: Token contract information for decimal place correction
- **End-of-day token price feeds**: Price data for USD conversion of token amounts

## 3. Step-by-step calculation

### Component A: Daily active users calculation

- **Purpose**: Identifies and counts unique users who interact with Gamma Strategies hypervisors each day
- **Logic**: Extract user addresses from `Deposit` events using the `sender` field (depositors) and from `Withdraw` events using the `to` field (withdrawers). Data is collected from both v1 and v2 hypervisor contracts across Uniswap, Zyberswap, and QuickSwap integrations on Ethereum, Arbitrum, Optimism, and Polygon. Timestamps are truncated to daily boundaries and users are aggregated using HyperLogLog for efficient distinct counting across multiple dimensions including chain, user type, and product classifications.
- **Key fields**: `block_timestamp` for daily grouping, `sender` from deposits, `to` from withdrawals, `chain` for network identification, `user_type` for categorization

### Component B: V1 hypervisor revenue calculation

- **Purpose**: Calculates protocol revenue from v1 hypervisor fee collection during rebalancing operations
- **Logic**: Extract fee amounts from `Rebalance` events using `feeAmount0` and `feeAmount1` fields for both tokens in each liquidity pair. Apply a fixed 10% protocol fee rate to the total fee amounts. Join with token address mappings to properly identify which tokens correspond to each fee amount. Filter to only include hypervisors classified as v1 based on block number thresholds. Convert token amounts to USD using end-of-day price feeds and apply decimal correction based on token metadata.
- **Key fields**: `feeAmount0` and `feeAmount1` for fee amounts, `token_0_address` and `token_1_address` for token identification, `block_timestamp` for daily aggregation

### Component C: V2 hypervisor revenue calculation

- **Purpose**: Calculates protocol revenue from v2 hypervisor fee collection through direct transfers to fee wallets
- **Logic**: Track token transfers to predefined protocol fee wallet addresses from v2 hypervisor contracts. Join with dynamic protocol fee rates derived from `ZeroBurn` events, which emit fee rate changes over time intervals. Match the correct fee rate to each transfer based on timestamp ranges. V2 hypervisors send fees directly to protocol wallets rather than using a percentage-based system. Convert transferred amounts to USD using end-of-day price feeds and decimal correction.
- **Key fields**: `value` from token transfers, `fee_rate` from `ZeroBurn` events with time ranges, `from_address` for hypervisor identification, `to_address` for fee wallet validation

### Component D: Hypervisor version and metadata management

- **Purpose**: Classifies hypervisor contracts by version and provides token address mappings
- **Logic**: Use `HypeAdded` events to identify hypervisor contract addresses and classify them as v1 or v2 based on block number thresholds specific to each chain. Extract token pair addresses by analyzing `Deposit` event transactions and matching deposited amounts with corresponding token transfers to identify which tokens belong to each hypervisor. Maintain dynamic protocol fee rates for v2 hypervisors by tracking `ZeroBurn` events that emit fee rate changes and calculating time intervals for rate applicability.
- **Key fields**: `hype` address for hypervisor identification, `block_number` for version classification, `amount0` and `amount1` for token mapping, `fee` from fee rate events

### Final aggregation

- **Combining components**: V1 and v2 revenue streams are combined using union operations, with all amounts converted to USD and aggregated by day, chain, and other dimensional attributes. Daily active users are aggregated across all interaction types (deposits and withdrawals) using HyperLogLog for efficient distinct counting.
- **Currency conversion**: All token amounts are converted to USD using end-of-day token price feeds, with proper decimal adjustment based on each token's decimal configuration. Price conversion occurs after fee calculations to ensure accurate USD values.
- **Time aggregation**: Both revenue and user data use daily time boundaries created by truncating `block_timestamp` to day granularity. All aggregations maintain chain-level and protocol version breakdowns.
- **Final calculation**: ARPU is calculated by dividing the total daily revenue (in USD) by the count of daily active users. The calculation uses the `calculate_arpu` macro which performs the division operation, handling cases where DAU might be zero by applying appropriate fill strategies. The result represents the average USD revenue generated per active user each day across the Gamma Strategies protocol.

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

Gamma StrategiesGAMMA

Average revenue per user (ARPU)

Average revenue per user (ARPU)

Competitive landscape