Collators aggregate parachain transactions block candidates and producing state transition proofs for validators based on those blocks.

Kilt is digital identity solution powered by Polkadot Relay chain.

KILT holders own and govern the protocol.

website

twitter

github

etherscan

Blockchains (L2)

Kilt

# Kilt Average fees per user (AFPU) Methodology

## 1. Overview

Average Fees Per User (AFPU) measures the average transaction fees paid per active user on the KILT protocol on a daily basis. This metric provides insight into user monetization and fee collection efficiency by dividing total daily transaction fees by the number of daily active users. The calculation follows a standard ARPU (Average Revenue Per User) methodology adapted for blockchain transaction fees.

## 2. Data sources

The AFPU calculation relies on three primary data sources:

- **KILT blockchain event logs**: Specifically `TransactionFeePaid` events that capture all successful transaction fee payments on the KILT blockchain, including both base transaction fees and optional tips paid by users
- **KILT blockchain extrinsic records**: Transaction records containing sender information (`id` field) used to identify unique active users who submitted transactions to the network
- **External price data**: End-of-day price feeds from CoinGecko for KILT Protocol tokens (using both 'kilt-protocol' and 'kilt-protocol-2' identifiers) to convert native token amounts to USD values

## 3. Step-by-step calculation

### Component A: Transaction fee extraction and processing
- **Purpose**: Extract and process all transaction fees paid on the KILT network
- **Logic**: The system identifies successful transactions by filtering for `TransactionFeePaid` events where the `success` field is true. From each event, it extracts two fee components from the JSON event data: the base transaction `amount` (from the second JSON element) and the optional `tip` (from the third JSON element). These amounts are converted from the native blockchain format by dividing by the KILT decimal factor of 1e15 to get human-readable token amounts. All fee data is timestamped using the `block_timestamp` and includes transaction identifiers like `extrinsic_hash` and `event_index` for traceability.
- **Key fields**: `amount` (base transaction fee), `tip` (optional additional fee), `block_timestamp` (transaction timing), `extrinsic_hash` (transaction identifier)

### Component B: Daily fee aggregation and USD conversion
- **Purpose**: Aggregate fees by day and convert to standardized USD amounts
- **Logic**: Transaction fees are aggregated by truncating timestamps to daily boundaries and summing both `amount` and `tip` components for each day. The system then converts these native KILT token amounts to USD using end-of-day price feeds from CoinGecko. Due to token evolution, the conversion process attempts two different CoinGecko identifiers ('kilt-protocol-2' and 'kilt-protocol') to ensure comprehensive price coverage across different time periods. The results from both conversion attempts are combined to create a complete daily fee dataset.
- **Key fields**: `timestamp` (daily boundary), `fees` (combined amount and tip in USD), `chain_id` ('kilt'), `product_id` ('Kilt Chain')

### Component C: Daily active user identification
- **Purpose**: Count unique active users who submitted transactions each day
- **Logic**: The system identifies active users by extracting the sender information from KILT extrinsic records, using the `id` field to identify unique addresses that initiated transactions. Users are classified as 'Transaction sender' user type and belong to the 'blockchains_l2' market sector. The data is processed to create daily distinct user counts, with timestamps truncated to daily boundaries to align with the fee aggregation timing.
- **Key fields**: `user_address` (unique sender identifier), `block_timestamp` (transaction timing), `user_type` ('Transaction sender')

### Component D: HyperLogLog user aggregation
- **Purpose**: Efficiently count distinct users across multiple dimensional breakdowns
- **Logic**: The system uses HyperLogLog (HLL) sketches to create efficient distinct user counts that can be aggregated across different dimensions. Daily user data is processed through HLL initialization with precision parameter 15, then aggregated across four dimensional breakdowns: project-level (all users), chain-level (by blockchain), user-type-level (by user classification), and product-level (by specific product). The HLL sketches are merged and extracted to produce final distinct user counts for each dimension and time period.
- **Key fields**: `user_dau` (distinct active user count), `dimensions` (aggregation level), `chain_id`, `product_id`, `user_type`

### Final aggregation
- **Combining components**: The daily fee totals (in USD) are divided by the daily active user counts using the standard ARPU calculation methodology. The division is performed at the daily level, matching fees and user counts by timestamp to calculate the average fees per user for each day
- **Currency conversion**: All fee amounts are converted to USD using end-of-day price feeds from CoinGecko, ensuring consistent currency representation across time periods and facilitating cross-protocol comparisons
- **Time aggregation**: Data is aggregated at daily boundaries by truncating timestamps to day level, ensuring consistent timing alignment between fee collection and user activity measurements
- **Final calculation**: The Average Fees Per User is calculated as: Daily Total Fees (USD) ÷ Daily Active Users = AFPU (USD per user). Missing days in the time series are filled with zero values to maintain complete temporal coverage, and the results are filtered based on chain availability to ensure data quality

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

KiltKILT

Archived

Average fees per user (AFPU)

Average fees per user (AFPU)

Competitive landscape