Liquidity providers deposit funds into DFX and receive a share of trading fees (supply-side fees).

DFX is a decentralized foreign exchange protocol deployed on Polygon, Ethereum & Arbitrum. DFX was founded in 2021 by Kevin Zhang and Adrian Li.

DFX tokenholders own and govern the protocol. They currently take a cut of the total trading fees paid by traders (revenue).

governance

github

twitter

discord

etherscan

website

Exchanges (DEX)

DFX Finance

# DFX Finance Average trading volume (per trade) Methodology

## 1. Overview

The DFX trading volume average per trade count metric measures the average USD value traded per transaction on the DFX protocol. 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 DFX's automated market maker (AMM) platform. The calculation aggregates data across multiple DFX contract versions (v1, v2, v2.2) and blockchain networks (Ethereum, Polygon, Arbitrum).

## 2. Data sources

- **Trade events**: Parsed `Trade` events from DFX Curve contracts across multiple versions (v1, v2, v2.2) on Ethereum, Polygon, and Arbitrum networks, containing token addresses, amounts, and transaction details
- **Transaction data**: Ethereum, Polygon, and Arbitrum transaction records providing user addresses and transaction metadata
- **Factory events**: Ethereum and Polygon `CurveFactoryV22_NewCurve_event` and `CurveFactoryV22_newCurve_function` data for dynamic fee tier calculation
- **Token metadata**: Token symbols and decimal precision information for proper amount normalization and trading pair identification
- **External price data**: End-of-day token price feeds in USD for volume conversion
- **Manual configurations**: Hardcoded fee tier data for specific Arbitrum contracts

## 3. Step-by-step calculation

### Component A: Trade data extraction and processing

- **Purpose**: Extract and standardize trade events from multiple DFX contract versions and blockchain networks
- **Logic**: Parse `Trade` events from DFX Curve contracts (v1 uses `Curve_Trade_event`, v2 uses `CurveV2_Trade_event`, v2.2 uses `CurveV22_Trade_event`) across Ethereum, Polygon, and Arbitrum. Extract key trade details including block timestamp, transaction hash, contract address, origin token address (`token0_address`), target token address (`token1_address`), origin amount (`token0_amount`), and target amount (`token1_amount`). Link trade events to transaction data to obtain user addresses (`user_address`) and enrich with protocol metadata including business line designation as "Exchange AMM"
- **Key fields**: `transaction_hash`, `log_index`, `account_address`, `user_address`, `token0_address`, `token1_address`, `token0_amount`, `token1_amount`, `block_timestamp`

### Component B: Fee tier determination

- **Purpose**: Calculate appropriate fee tiers for each trading pair based on contract version and deployment parameters
- **Logic**: Apply multi-source fee tier logic combining manual configurations for specific Arbitrum contracts with hardcoded rates (0.001 and 0.003), dynamic calculation from Ethereum and Polygon factory events where fee tier equals epsilon divided by 10^18 from `CurveFactoryV22_NewCurve_event` and `CurveFactoryV22_newCurve_function` data, and historical fallback using 0.0005 rate for trades occurring before February 13, 2023 when protocol fees were not yet implemented
- **Key fields**: `fee_tier`, `account_address`, `chain`, `epsilon` value from factory events

### Component C: Volume calculation with decimal correction and USD conversion

- **Purpose**: Convert raw token amounts to standardized USD trading volumes accounting for token decimals and price data availability
- **Logic**: Normalize token amounts by dividing raw values by 10 raised to the power of token decimal places from token metadata. Join with end-of-day token price feeds to obtain USD prices for both tokens in each trade. Apply USD conversion logic where if both tokens have available prices, use the lesser of the two USD values to avoid double-counting volume; if only one token has price data available, use that token's USD value; if neither token has price data, assign zero volume. Aggregate daily volumes by summing converted USD amounts across all trades, grouped by day, chain, contract address, and other relevant dimensions
- **Key fields**: `trading_volume` (final USD amount), `token0_amount` and `token1_amount` (decimal-corrected), `price_usd` from price feeds

### Component D: Trade count aggregation

- **Purpose**: Count the number of unique trading transactions per day for average calculation
- **Logic**: Count distinct transaction hashes from the processed trade data, grouped by day, chain, and other relevant dimensions. This provides the denominator for the average calculation by capturing the total number of separate trading events
- **Key fields**: `trade_count` (count of distinct `transaction_hash` values)

### Final aggregation

- **Combining components**: Join daily trading volume totals with daily trade counts using timestamp and other matching dimensions. Both components are aggregated to the same daily grain to ensure proper alignment
- **Currency conversion**: All volume calculations are performed in USD using end-of-day price feeds, with volumes already converted during the volume calculation step
- **Time aggregation**: Data is aggregated to daily boundaries using timestamp truncation, with both volume and trade count metrics aligned to the same daily grain
- **Final calculation**: Calculate the average trading volume per trade by dividing total daily trading volume by daily trade count using safe division to handle cases where trade count might be zero, producing the final metric value representing average USD value per transaction

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

DFX FinanceDFX

Average trading volume (per trade)

Average trading volume (per trade)

Competitive landscape