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

KyberSwap is a non-custodial exchange protocol & aggregator built on Ethereum and other adjacent blockchains. KyberSwap was founded by Loi Luu and Victor Tran in 2017.

KNC tokenholders own and govern the protocol. They currently take a cut of the total trading fees paid by traders (revenue). Kyber Network raised $52 million in an ICO in 2017.

governance

github

twitter

discord

etherscan

website

DEX aggregators

KyberSwap

# KyberSwap Average trading volume (per trade) Methodology

## 1. Overview

The KyberSwap average trading volume per trade count metric measures the average USD value traded per transaction across KyberSwap's decentralized exchange infrastructure. This metric is calculated by dividing the total daily trading volume by the total number of unique trades, providing insight into the typical trade size on the platform. The calculation combines data from KyberSwap's AMM pools (versions 2 and 3), aggregator routing, and legacy trading systems across multiple blockchain networks.

## 2. Data sources

The calculation uses several types of blockchain data and external sources:

- **AMM swap events**: Parsed `Swap` events from KyberSwap v2 and v3 liquidity pools across Ethereum, Arbitrum, Avalanche, BSC, Fantom, Optimism, Polygon, and zkSync Era networks
- **Aggregator swap events**: Parsed `Swapped` events from MetaAggregationRouter and MetaAggregationRouterV2 contracts across supported chains
- **Legacy trade events**: Historical `KyberTrade` and `ExecuteTrade` events from original KyberNetwork contracts on Ethereum
- **Pool creation events**: `PoolCreated` events from Factory and ElasticFactory contracts providing trading pair metadata and fee tier information
- **Transaction records**: Blockchain transaction data for user address identification and timestamp information
- **End-of-day price feeds**: Daily token price data in USD for volume conversion
- **Token metadata**: Token symbols and decimal precision information for amount calculations

## 3. Step-by-step calculation

### Component A: AMM trade data extraction
- **Purpose**: Extracts swap transactions from KyberSwap AMM pools
- **Logic**: Collects `Swap` events from KyberSwap v2 and v3 pools across multiple chains. For v2 pools, calculates token amount changes by subtracting output amounts from input amounts (`amount0In - amount0Out` and `amount1In - amount1Out`). For v3 pools, uses delta quantities (`deltaQty0` and `deltaQty1`) directly. Applies decommission filter to exclude v3 trades after November 23, 2023 due to contract exploit. Joins with transaction data to obtain user addresses from the `from_address` field
- **Key fields**: Block timestamp for daily aggregation, transaction hash and log index for unique identification, token amounts with proper sign handling, user address from transaction data

### Component B: Aggregator and legacy trade data extraction  
- **Purpose**: Captures trades routed through KyberSwap's aggregation service and historical legacy contracts
- **Logic**: Extracts `Swapped` events from MetaAggregationRouter contracts which facilitate multi-hop trades across different DEXs. Handles native token identifier substitution by replacing `0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee` with corresponding wrapped token addresses for each chain. Includes legacy KyberNetwork trade events from Ethereum mainnet for historical completeness. Uses `spentAmount` and `returnAmount` fields for aggregator trades, and various amount fields for legacy events
- **Key fields**: Spent and return amounts for aggregator trades, source and destination token addresses with native token conversion, transaction metadata for user identification

### Component C: Trading pair metadata enrichment
- **Purpose**: Provides token pair information and fee tier data for proper trade classification
- **Logic**: Combines pool creation events from Factory and ElasticFactory contracts across all supported chains and versions. Maps pool addresses to their constituent token pairs (`token0` and `token1` addresses). For v2 pools, sets fee tier as zero since fees are calculated separately. For v3 pools, extracts fee information from `swapFeeUnits` field and converts to decimal format by dividing by 100,000. Joins with token metadata to obtain symbols and decimal precision, creating human-readable pool names in format `TOKEN0-TOKEN1`
- **Key fields**: Pool address as unique identifier, token addresses for both sides of the pair, fee tier as decimal value, token decimals for amount normalization, account name for display purposes

### Component D: Volume calculation and USD conversion
- **Purpose**: Converts raw token amounts to USD trading volumes with anti-manipulation measures
- **Logic**: Joins trade data with trading pair metadata to obtain token decimal information. Calculates normalized token amounts by dividing raw amounts by 10 raised to the token's decimal precision. Applies absolute value to handle directional differences between buy and sell operations. Converts token amounts to USD by joining with end-of-day price feeds for both tokens in each pair. Implements anti-manipulation logic by taking the minimum USD value between the two tokens (`least(token0_amount * token0_price, token1_amount * token1_price)`). This prevents inflated volumes from manipulated token prices. Groups trades by day using timestamp truncation, transaction hash, and log index for proper aggregation
- **Key fields**: Normalized `token0_amount` and `token1_amount` values, USD prices for both tokens, final `trading_volume` as minimum USD value between the pair

### Component E: Trade count calculation
- **Purpose**: Counts unique trading transactions for the denominator of the average calculation
- **Logic**: Uses the same underlying trade data from the volume calculation but focuses on transaction counting rather than volume aggregation. Groups by daily timestamp, chain, market sector, business segment, and product identifiers. Counts distinct transaction hashes to avoid double-counting trades that may have multiple log entries within the same transaction. Applies the same time boundaries and filtering logic as the volume calculation to ensure consistency between numerator and denominator
- **Key fields**: Distinct count of `transaction_hash` values, daily timestamp grouping, protocol classification fields

### Final aggregation
- **Combining components**: Both trading volume and trade count metrics are aggregated daily across all chains, versions, and business lines. The volume metric sums all USD trading volumes, while the trade count metric sums all distinct transaction counts for the same time periods and protocol segments
- **Currency conversion**: All volume calculations use end-of-day USD price feeds applied at the trade level before daily aggregation. This ensures consistent pricing across all trades within each day
- **Time aggregation**: Daily boundaries are established using timestamp truncation to day level. All trades are grouped by their block timestamp truncated to the start of day
- **Final calculation**: The average volume per trade is calculated using safe division of total daily trading volume by total daily trade count (`safe_divide(trading_volume, trade_count)`). This handles edge cases where trade count might be zero and prevents division errors. The result represents the mean USD value per trading transaction for each day

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

KyberSwapKNC

Average trading volume (per trade)

Average trading volume (per trade)

Competitive landscape