Liquidity providers deposit funds into SolidLizard and stake their LP tokens to receive SLIZ tokens (token incentives).

SolidLizard is a non-custodial exchange protocol built on Arbitrum. SolidLizard was founded by an anonymous team and launched in 2023.

SLIZ tokenholders own and govern the protocol. They vote for pools where they wish to receive trading fees and external bribes from, while pools receive SLIZ emissions in respect to their share of votes.

twitter

discord

etherscan

website

Exchanges (DEX)

SolidLizard

# SolidLizard Fees Methodology

## 1. Overview

The SolidLizard fees metric measures daily trading fees collected by the SolidLizard decentralized exchange (DEX) on Arbitrum. SolidLizard is an automated market maker (AMM) that collects fees from traders when they swap tokens in liquidity pools. The metric captures fees collected in both tokens of each trading pair and converts them to USD values for aggregation. This provides insight into the protocol's fee generation and trading activity.

## 2. Data sources

The calculation uses the following blockchain and external data sources:

- **Fee collection events**: Parsed `Fees` events from SolidLizard v1 pair contracts on Arbitrum, containing fee amounts collected in both tokens of trading pairs
- **Trading pair creation events**: Parsed `PairCreated` events from SolidLizard v1 PairFactory contract on Arbitrum, providing the mapping between pair contract addresses and their underlying token addresses
- **Token metadata**: Token information including decimal places and symbols for proper unit conversion and pair identification
- **End-of-day price feeds**: Daily token price data in USD for currency conversion
- **Chain availability filters**: Configuration data to ensure metrics are only calculated for supported chains and time periods

## 3. Step-by-step calculation

### Component A: Fee event extraction
- **Purpose**: Extracts raw trading fee data from SolidLizard pair contracts
- **Logic**: Parses `Fees` events emitted by SolidLizard v1 pair contracts on Arbitrum when fees are collected from trades. Each event contains the pair contract address, fee collector address (sender), and fee amounts in both tokens (`amount0` and `amount1`). Events are filtered to include only SolidLizard v1 contracts and classified with business metadata (market sector as 'exchanges', business segment as 'dex')
- **Key fields**: `block_timestamp` for timing, `account_address` (pair contract), `fee_collector_address` (sender), `token0_amount` and `token1_amount` for fee quantities

### Component B: Trading pair dimensions
- **Purpose**: Creates metadata mapping for trading pairs to identify their underlying tokens
- **Logic**: Processes `PairCreated` events from the SolidLizard v1 PairFactory contract to build a registry of all trading pairs. Each event provides the newly created pair contract address along with the addresses of the two underlying tokens (`token0` and `token1`). This data is enriched with token metadata including decimal places and symbols to create human-readable pair names in the format 'TOKEN0-TOKEN1'
- **Key fields**: `account_address` (pair contract), `token0_address`, `token1_address`, `token0_decimals`, `token1_decimals`, `account_name` (formatted pair name)

### Component C: Daily fee aggregation and decimal correction
- **Purpose**: Aggregates fee events by day and applies proper decimal formatting
- **Logic**: Groups fee events by day using timestamp truncation and sums fee amounts for each trading pair. Raw token amounts are converted from blockchain integer format to decimal format by dividing by 10 raised to the power of each token's decimal places. This ensures amounts are in standard token units rather than the smallest indivisible units used on-chain
- **Key fields**: `timestamp` (daily), `token0_amount` and `token1_amount` (decimal-corrected), aggregated by pair and day

### Component D: USD conversion
- **Purpose**: Converts token fee amounts to USD values for standardized reporting
- **Logic**: Joins the decimal-corrected fee amounts with end-of-day price feeds for both tokens in each pair. Each token amount is multiplied by its corresponding USD price on the same date. The USD values for both tokens are then summed to get the total fee value for each pair on each day. Missing prices are handled by treating the fee contribution as zero using coalesce logic
- **Key fields**: `fees` (total USD value), derived from `token0_amount * price_usd + token1_amount * price_usd`

### Final aggregation
- **Combining components**: Fee events are joined with trading pair metadata on chain and pair contract address to access token information needed for decimal correction and USD conversion. Price data is joined separately for each token using timestamp, token address, and chain as keys
- **Currency conversion**: End-of-day token prices are used for USD conversion, with the calculation performed at the daily grain to match price feed availability
- **Time aggregation**: All fees are aggregated to daily boundaries using timestamp truncation to day level
- **Final calculation**: The final fees metric represents the sum of USD-converted trading fees collected across all SolidLizard trading pairs on each day, with any data gaps filled with zeros using the finalize_metric_fees macro to ensure complete time series data

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

Total value users pay to use a protocol (gross fees, user-paid fees).

SolidLizardSLIZ

Fees

Fees

Competitive landscape