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 Trading volume Methodology

## 1. Overview

DFX trading volume measures the daily USD value of trades executed across DFX's decentralized exchange AMM pools. This metric captures trading activity from DFX's curve-based automated market makers across multiple blockchain networks and protocol versions. The calculation aggregates trade events from DFX's smart contracts, normalizes token amounts, converts values to USD using end-of-day prices, and applies appropriate fee tier classifications to produce a comprehensive daily trading volume metric.

## 2. Data sources

The calculation relies on several key data sources:

- **DFX trade events**: Parsed `Trade` events from DFX's curve contracts across multiple versions (`Curve_Trade_event` for v1, `CurveV2_Trade_event` and `CurveV22_Trade_event` for v2) on Ethereum, Polygon, and Arbitrum networks
- **Blockchain transaction data**: Transaction records from Ethereum, Polygon, and Arbitrum containing user addresses, timestamps, and transaction metadata
- **Contract creation events**: DFX curve factory contract creation events (`NewCurve` events) and corresponding function calls (`newCurve` functions) used to determine fee tiers for trading pools
- **Token metadata**: Token information including symbols and decimal places for proper amount normalization and trading pair identification
- **End-of-day price feeds**: Daily USD price data for tokens traded on DFX platforms

## 3. Step-by-step calculation

### Component A: Trade event extraction
- **Purpose**: Extract raw trade data from DFX contracts across all supported versions and chains
- **Logic**: Query `Trade` events from DFX's curve contracts, covering v1 contracts on Ethereum and Polygon, and v2 contracts (including v2.2) on Ethereum, Polygon, and Arbitrum. Join trade events with transaction records to capture user addresses and block timestamps. Extract key trade parameters including contract address, origin token, target token, origin amount, and target amount from the event logs.
- **Key fields**: Block timestamp (`block_timestamp`), contract address (`account_address`), user address from transaction (`user_address`), token addresses (`token0_address`, `token1_address`), and token amounts (`token0_amount`, `token1_amount`)

### Component B: Fee tier determination
- **Purpose**: Establish fee tiers for each DFX trading pool
- **Logic**: Combine manually configured fee tiers for specific pool addresses with dynamically determined fee tiers from curve factory contract creation events. For pools created through factory contracts, extract the epsilon parameter from the `newCurve` function call data and normalize it by dividing by 10^18 to get the fee tier percentage. Apply a historical fallback rule where trades before February 13, 2023 use a default fee tier of 0.0005 (0.05%).
- **Key fields**: Chain identifier (`chain`), protocol version (`version`), pool contract address (`account_address`), and calculated fee tier (`fee_tier`)

### Component C: Volume aggregation and normalization  
- **Purpose**: Aggregate trade data daily and normalize token amounts using proper decimal places
- **Logic**: Group trades by day using timestamp truncation to daily boundaries. Join trade data with token metadata to obtain decimal places and symbol information for each token. Normalize token amounts by dividing raw amounts by 10 raised to the power of the token's decimal places. Create trading pair names by concatenating token symbols. Sum normalized amounts for each token across all trades within each day, grouped by chain, version, account address, and fee tier.
- **Key fields**: Daily timestamp (`timestamp`), normalized token amounts (`token0_amount`, `token1_amount`), trading pair name (`account_name`), and fee tier (`fee_tier`)

### Component D: USD conversion with price fallback logic
- **Purpose**: Convert normalized token amounts to USD values using end-of-day price feeds
- **Logic**: Join normalized trade data with end-of-day token price feeds for both tokens in each trading pair. Apply a sophisticated fallback logic for USD conversion: when both tokens have available prices, take the minimum USD value between the two sides to avoid double-counting; when only one token has a price, use that token's USD value; when neither token has a price, assign zero volume. This approach ensures conservative volume reporting while maximizing coverage.
- **Key fields**: Token prices (`price_usd` for both tokens) and calculated trading volume (`trading_volume`)

### Final aggregation
- **Combining components**: Sum daily trading volumes across all pools, grouping by timestamp, chain, business classification fields (business line as 'Exchange AMM', market sector as 'exchanges', business segment as 'dex'), version, and fee tier
- **Currency conversion**: USD conversion occurs at the individual trade level using end-of-day prices with the minimum-value fallback logic described above
- **Time aggregation**: All trades are aggregated to daily boundaries using timestamp truncation, with the day serving as the primary time grain
- **Final calculation**: The final metric represents the sum of USD trading volumes across all DFX pools for each day, maintaining granularity by chain, version, and fee tier while applying standardized business classifications and chain availability filters

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

Total value of spot trades executed on the exchange.

DFX FinanceDFX

Trading volume

Trading volume

Competitive landscape

Chain breakdown