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

SyncSwap is a non-custodial exchange protocol built on zkSync Era (originally a fork of Uniswap). SyncSwap was founded by an anonymous team in 2023.

The SyncSwap team owns and governs the protocol. They currently take a cut of the trading fees paid by the users (revenue).

github

twitter

discord

website

Exchanges (DEX)

SyncSwap

# SyncSwap Trading volume Methodology

## 1. Overview

The SyncSwap trading volume metric measures the total USD value of tokens traded on the SyncSwap decentralized exchange on zkSync Era. This metric aggregates daily trading activity across both Classic and Stable pool types, applying price manipulation protection and accounting for dynamic fee structures. The calculation converts all token trades to USD values and takes the conservative approach of using the lesser value between the two tokens in each trade to filter out potential price manipulation attempts.

## 2. Data sources

The trading volume calculation relies on several key data sources:

- **Blockchain events**: Parsed zkSync Era `Swap` events from `ClassicPool` and `StablePool` contracts capturing individual trade executions with token amounts
- **Pool creation events**: zkSync Era `PoolCreated` events from `ClassicPoolFactory` and `StablePoolFactory` contracts establishing trading pairs and initial fee configurations
- **Transaction data**: zkSync Era transaction records providing user addresses and transaction context
- **Fee management events**: zkSync Era `SetPoolSwapFee` and `SetPoolProtocolFee` events from the `FeeManager` contract tracking fee structure changes over time
- **External data**: End-of-day token price feeds for USD conversion and token metadata including symbols and decimal places
- **Token metadata**: Token symbols, decimal places, and contract addresses for proper amount calculations and pair identification

## 3. Step-by-step calculation

### Component A: Trade extraction
- **Purpose**: Extract and process individual trade events from SyncSwap pools
- **Logic**: Parse `Swap` events from both `ClassicPool` and `StablePool` contracts on zkSync Era. For each swap event, calculate the net change in token amounts by taking the difference between input amounts (`amount0In`, `amount1In`) and output amounts (`amount0Out`, `amount1Out`). Join with transaction records to identify the actual user address (as opposed to the contract user). Each trade is assigned a unique identifier based on block number and log index for chronological ordering.
- **Key fields**: Block timestamp for daily aggregation, transaction hash for deduplication, calculated `token0_amount` and `token1_amount` representing net token changes, user addresses, and pool contract addresses

### Component B: Trading pair dimensions
- **Purpose**: Establish trading pair metadata and initial fee configurations
- **Logic**: Process `PoolCreated` events from both Classic and Stable pool factories to identify all valid trading pairs. Extract token addresses for each pair, handling the special case where native ETH addresses are converted to wrapped ETH addresses for consistency. Retrieve token metadata including decimal places and symbols to enable proper amount calculations and generate readable pair names. Establish initial fee tiers with Classic pools using 0.2% fees and Stable pools using 0.04% fees, along with 5% protocol fees.
- **Key fields**: Pool contract addresses, `token0_address` and `token1_address`, decimal places for each token, generated account names combining token symbols, and initial `fee_tier` and `protocol_fee_tier` values

### Component C: Fee update tracking
- **Purpose**: Track changes to fee structures over time for accurate volume calculations
- **Logic**: Monitor `SetPoolSwapFee` and `SetPoolProtocolFee` events from the `FeeManager` contract to track when pools update their fee structures. Convert raw fee values from basis points to decimal percentages by dividing by 100,000. Create chronological sequences using the `lead()` function to determine the effective period for each fee configuration. This enables applying the correct fees to trades based on when they occurred relative to fee changes.
- **Key fields**: Updated `fee_tier` and `protocol_fee_tier` values, effective date ranges through `id` and `next_id` fields, and pool addresses for matching with specific trading pairs

### Component D: Volume aggregation with dynamic fees
- **Purpose**: Combine trades with trading pair data and apply current fee structures
- **Logic**: Join individual trades with trading pair dimensions to get token metadata and initial fee configurations. Apply any applicable fee updates by matching trade timestamps with fee update effective periods using the chronological identifier system. Correct raw token amounts by dividing by the appropriate number of decimal places (typically 18 for most tokens). Aggregate corrected amounts by day, summing absolute values to capture total trading volume regardless of trade direction.
- **Key fields**: Daily aggregated `token0_amount` and `token1_amount` with decimal corrections applied, updated fee tiers reflecting any changes, and all necessary identifiers for final USD conversion

### Component E: USD conversion with manipulation protection
- **Purpose**: Convert token amounts to USD values while protecting against price manipulation
- **Logic**: Join with end-of-day price feeds to get USD prices for both tokens in each trading pair on the trade date. Calculate USD values by multiplying the corrected token amounts by their respective prices. Apply manipulation protection by taking the lesser of the two USD values using the `least()` function - this conservative approach filters out trades where one token may have a manipulated or stale price. Sum all daily USD trade volumes across all pools and trading pairs.
- **Key fields**: Individual `trading_volume` values in USD for each trade, with manipulation protection applied through minimum value logic

### Final aggregation
- **Combining components**: All daily trading volumes across different pools and token pairs are summed together to create the total daily trading volume
- **Currency conversion**: USD conversion occurs at the trade level using end-of-day prices matched by date, with manipulation protection applied through minimum value selection
- **Time aggregation**: Trades are aggregated to daily boundaries using timestamp truncation, with the final metric representing total USD trading volume for each calendar day
- **Final calculation**: The final metric value equals the sum of all individual trade volumes in USD, where each trade volume is the lesser of the two token values (token0_amount × token0_price_usd, token1_amount × token1_price_usd), aggregated across all SyncSwap pools and trading pairs for each day

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

Total value of spot trades executed on the exchange.

SyncSwap

Trading volume

Trading volume

Competitive landscape

Chain breakdown