Integral provides low slippage on large trades by executing orders using a time-weighted average price (TWAP).

Integral is a non-custodial TWAP-based exchange on Ethereum and Arbitrum that specializes in handling large trades with low slippage. Integral was founded by a group of pseudonymous developers, mathematicians and financial engineers, and their flagship product Integral SIZE was launched in 2022.

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

github

twitter

discord

etherscan

website

Exchanges (DEX)

Integral

# Integral Trade count Methodology

## 1. Overview

Trade count measures the number of unique trading transactions executed on the Integral protocol per day. This metric counts distinct transaction hashes that contain swap events, providing insight into trading activity and user engagement on Integral's decentralized exchange across Ethereum and Arbitrum networks. Each transaction hash represents one unique trade, regardless of how many individual swaps or events occurred within that transaction.

## 2. Data sources

- **Integral swap events**: Parsed `TwapPair_Swap_event` logs from Integral protocol smart contracts on Ethereum and Arbitrum, containing transaction hashes, token amounts, and swap details
- **Integral pair creation events**: Parsed `TwapFactory_PairCreated_event` logs that define valid trading pairs and their token addresses
- **Integral fee events**: Parsed `TwapPair_SetSwapFee_event` logs providing fee tier information for trading pairs
- **Token metadata**: Token symbols, decimal places, and identifiers for proper token identification and display names
- **End-of-day price feeds**: Daily token price data for USD conversion context (used in intermediate processing)

## 3. Step-by-step calculation

### Component A: Raw trade extraction
- **Purpose**: Extract all swap events from Integral protocol contracts
- **Logic**: Collect all `TwapPair_Swap_event` logs from Integral v1 contracts on Ethereum and Arbitrum chains. Each event contains the transaction hash, log index, contract address, and token amount changes (`amount0In`, `amount0Out`, `amount1In`, `amount1Out`). Calculate net token amount changes by subtracting outgoing amounts from incoming amounts for both tokens in the pair
- **Key fields**: `transaction_hash`, `log_index`, `account_address` (trading pair contract), `token0_amount`, `token1_amount`, `block_timestamp`

### Component B: Trading pair metadata
- **Purpose**: Identify valid trading pairs and their token properties
- **Logic**: Extract trading pair creation events from `TwapFactory_PairCreated_event` logs to get valid pair contract addresses and their underlying token addresses. Join with token metadata to get decimal places and symbols for each token in the pair. Create readable pair names by concatenating token symbols
- **Key fields**: `account_address` (pair contract), `token0_address`, `token1_address`, `token0_decimals`, `token1_decimals`, `account_name`

### Component C: Fee tier information
- **Purpose**: Capture fee tier data for trading pairs over time
- **Logic**: Extract fee setting events from `TwapPair_SetSwapFee_event` logs and group by day and trading pair address. Calculate average fee tier per day for each pair. Apply forward-filling to propagate the most recent fee tier value to subsequent days when no fee changes occur
- **Key fields**: `timestamp`, `account_address`, `fee_tier`

### Component D: Trade volume processing (intermediate)
- **Purpose**: Combine trade data with pair metadata and calculate USD values
- **Logic**: Join swap events with trading pair metadata to validate trades and get token properties. Correct token amounts using decimal places and convert absolute values to account for both buy and sell directions. Join with end-of-day price feeds to convert token amounts to USD values. Use the minimum USD value between the two tokens in each swap to filter out potential price manipulation. Group by day, transaction hash, and log index to aggregate trade data
- **Key fields**: `timestamp`, `transaction_hash`, `log_index`, `chain`, business classification fields, `trading_volume`

### Final aggregation
- **Combining components**: Use the processed trade volume data as the base dataset containing all validated trades with their transaction hashes and metadata
- **Currency conversion**: Not applicable for trade count metric - only transaction hashes are counted
- **Time aggregation**: Truncate all timestamps to daily boundaries using day-level timestamp truncation
- **Final calculation**: Group all trade records by day, chain, market sector, business segment, and product identifiers, then count distinct transaction hashes using `COUNT(DISTINCT transaction_hash)`. Apply the `finalize_metric_trade_count` macro to standardize the output format, fill missing days with zero values, and add required metadata columns. Filter final results based on chain availability settings to ensure data quality.

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

Number of trades executed on a decentralized exchange.

IntegralITGR

Trade count

Trade count

Competitive landscape

Chain breakdown