Liquidity providers deposit funds into Balancer and receive trading fees from traders (supply-side fees). In addition, Balancer provides liquidity providers with additional yield using boosted pools.

Balancer is a non-custodial exchange protocol built on Ethereum. Balancer was founded by Fernando Martinelli and launched in 2018.

BAL tokenholders own and govern the protocol. They currently take a cut of the total trading and yield fees (revenue). Balancer's investors include DeFiance Capital, Three Arrows Capital, Alameda Research, etc.

governance

github

twitter

discord

etherscan

website

Exchanges (DEX)

Balancer

# Balancer Average fees per user (AFPU) Methodology

## 1. Overview

Average fees per user (AFPU) measures the daily average fee revenue generated per active user on the Balancer protocol. This metric is calculated by dividing total daily fees collected by the protocol by the number of distinct daily active users. The calculation covers all supported chains (Ethereum, Arbitrum, Avalanche, Base, Gnosis, and Polygon) but excludes Optimism data. AFPU provides insight into the revenue efficiency and user monetization of the Balancer decentralized exchange.

## 2. Data sources

The AFPU calculation relies on several types of blockchain and external data:

- **Balancer protocol events**: Parsed `PoolBalanceChanged` events from Balancer V2 Vault contracts tracking protocol fee collections, `PoolRegistered` events for LP token fee tracking, `Swap` events for trading activity, and `FlashLoan` events for flashloan activity
- **Blockchain transaction data**: Transaction records from supported chains to extract user addresses and transaction metadata
- **Token transfer events**: Blockchain token transfer logs to track LP token fees sent to the protocol fees collector
- **Protocol configuration events**: `SwapFeePercentageChanged` and `FlashLoanFeePercentageChanged` events tracking fee tier updates
- **End-of-day price feeds**: Daily closing prices for token-to-USD conversions across all supported assets
- **Token metadata**: Token decimals, symbols, and contract addresses for proper amount calculations and display

## 3. Step-by-step calculation

### Component A: Protocol fee collection from trading

- **Purpose**: Captures protocol fees collected from trading activities through the Balancer V2 Vault
- **Logic**: Monitors `PoolBalanceChanged` events from Balancer V2 Vault contracts across all supported chains. These events contain arrays of token addresses and corresponding protocol fee amounts collected by the protocol. The system identifies fee collection by filtering events where tokens are transferred to the hardcoded protocol fees collector address `0xce88686553686da562ce7cea497ce749da109f9f`. Token addresses and fee amounts are unnested from arrays and paired using array offsets. Additionally, LP token fees are captured by monitoring token transfers where LP tokens (identified through `PoolRegistered` events) are minted to the protocol fees collector address
- **Key fields**: Pool ID (`poolid`) parsed to extract contract addresses, token addresses array (`tokens`), protocol fee amounts array (`protocolfeeamounts`), block timestamp, transaction hash, and chain identifier

### Component B: Flashloan fee collection

- **Purpose**: Captures explicit fees charged for flashloan services
- **Logic**: Extracts flashloan activity from `FlashLoan` events emitted by Balancer V2 Vault contracts. These events contain explicit fee amounts charged for flashloan services. The system joins with transaction data to extract user addresses and applies protocol fee tier configurations from `FlashLoanFeePercentageChanged` events. Fee amounts are processed directly without complex calculations since they represent explicit charges
- **Key fields**: Token address (`token`), flashloan amount (`amount`), fee amount (`feeAmount`), user address from transaction data, and protocol fee tier from configuration events

### Component C: Daily active user counting

- **Purpose**: Counts distinct users engaging with the Balancer protocol daily
- **Logic**: Identifies active users from two sources: trading users from `Swap` events and flashloan users from `FlashLoan` events. User addresses are extracted by joining event data with blockchain transaction records using transaction hashes. The system categorizes users as 'Trader' type from swap activities and 'Flashloan Trader' type from flashloan activities. Users are aggregated using HyperLogLog (HLL) counting for efficient distinct counting across large datasets. Optimism chain data is excluded from user counting as those users are attributed to Beethoven X protocol
- **Key fields**: User address (`user_address`) extracted from transaction `from_address`, user type classification, chain identifier, and daily timestamp boundaries

### Component D: Fee amount processing and USD conversion

- **Purpose**: Standardizes and converts all fee amounts to USD values
- **Logic**: Applies decimal corrections by dividing token amounts by `pow(10, decimals)` using token metadata. Converts corrected amounts to USD by multiplying with end-of-day price feeds matched on timestamp, token address, and chain. Excludes specific problematic tokens like the Gnosis stabal3 token address `0x2086f52651837600180de173b09470f54ef74910`. Aggregates fees across trading and flashloan sources, applying protocol fee tiers from configuration events to calculate total fees from protocol fee amounts
- **Key fields**: Corrected token amounts, USD conversion rates (`price_usd`), protocol fee tiers, and final USD fee values

### Final aggregation

- **Combining components**: Daily fees from protocol fee collection and flashloan fees are summed together. Daily active users are counted using HLL aggregation across trader and flashloan trader types. Both metrics are aggregated to daily boundaries using timestamp truncation
- **Currency conversion**: All fee amounts are converted to USD using end-of-day price feeds matched on date, token address, and chain. Missing prices default to zero values
- **Time aggregation**: Data is aggregated to daily boundaries using `timestamp_trunc(block_timestamp, day)`. The system fills missing days with zero values for both fees and user counts
- **Final calculation**: AFPU is calculated by dividing total daily fees (in USD) by total daily active users count. The calculation uses the `calculate_arpu` macro with parameters specifying fee revenue as the numerator and daily active users as the denominator. Days with zero users result in zero AFPU values rather than division errors

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

BalancerBAL

Average fees per user (AFPU)

Average fees per user (AFPU)

Competitive landscape