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 Trade count Methodology

## 1. Overview

The SolidLizard trade count metric measures the number of unique trading transactions executed on the SolidLizard decentralized exchange per day. This metric counts distinct transaction hashes that contain swap events on SolidLizard's AMM pools, providing insight into daily trading activity and user engagement on the platform. The calculation processes raw Arbitrum blockchain data from SolidLizard v1 contracts, normalizes token amounts, applies price-based filtering to reduce manipulation, and aggregates to daily unique transaction counts.

## 2. Data sources

The calculation uses the following raw data sources:

- **Arbitrum swap events**: Parsed `Pair_Swap_event` logs from SolidLizard v1 pair contracts containing swap amounts, user addresses, and transaction details
- **Arbitrum factory events**: Parsed `PairFactory_PairCreated_event` logs from SolidLizard's factory contract that define trading pairs and their token compositions
- **Arbitrum transaction records**: Complete transaction data providing user addresses and transaction metadata for each swap
- **End-of-day price feeds**: Daily USD price data for tokens traded on SolidLizard, used for conversion and filtering
- **Token metadata**: Token information including decimal places and symbols for proper amount normalization and pair naming

## 3. Step-by-step calculation

### Component A: Raw swap event extraction
- **Purpose**: Extract and process individual swap transactions from SolidLizard pair contracts
- **Logic**: Collect all `Pair_Swap_event` logs from SolidLizard v1 pair contracts on Arbitrum. For each swap, calculate the net token change by subtracting `amount0Out` from `amount0In` for the first token and `amount1Out` from `amount1In` for the second token. Join with Arbitrum transaction data to identify the actual user address (not just the contract caller). Add business classification metadata including market sector as 'exchanges', business segment as 'dex', and business line as 'Exchange AMM'.
- **Key fields**: `transaction_hash`, `log_index`, `account_address` (pair contract), `user_address`, `token0_amount`, `token1_amount`, `block_timestamp`

### Component B: Trading pair metadata enrichment
- **Purpose**: Add token metadata and trading pair information to enable proper amount normalization
- **Logic**: Extract trading pair definitions from `PairFactory_PairCreated_event` logs to identify all SolidLizard trading pairs and their token compositions. Join with token metadata to obtain decimal places and symbols for both tokens in each pair. Create readable pair names by concatenating token symbols with a hyphen separator. This provides the essential metadata needed to normalize raw token amounts and identify which tokens are being traded.
- **Key fields**: `token0_address`, `token1_address`, `token0_decimals`, `token1_decimals`, `account_name` (pair name)

### Component C: Amount normalization and USD conversion
- **Purpose**: Normalize token amounts and convert to USD values for filtering and standardization
- **Logic**: Join swap events with trading pair metadata to access token decimal information. Normalize token amounts by dividing the absolute value of each amount by 10 raised to the power of the token's decimal places. Join with end-of-day price feeds to get USD prices for both tokens in each trading pair. Convert normalized token amounts to USD values by multiplying by the respective token prices. Apply price manipulation filtering by taking the lesser of the two USD amounts (token0 USD value vs token1 USD value) to reduce the impact of price manipulation or flash loan attacks.
- **Key fields**: `token0_amount` (normalized), `token1_amount` (normalized), `trading_volume` (USD value)

### Component D: Daily trade aggregation
- **Purpose**: Group trades by day and count unique transactions
- **Logic**: Truncate block timestamps to day boundaries to create daily aggregation periods. Group all processed swap data by date, chain, market sector, business segment, and product. Count distinct transaction hashes within each day to avoid double-counting transactions that may contain multiple swap events. This ensures that a single transaction with multiple swaps is counted as one trade rather than multiple trades.
- **Key fields**: `timestamp` (daily), `trade_count` (distinct transaction hashes)

### Final aggregation
- **Combining components**: All components flow sequentially from raw event extraction through metadata enrichment, normalization, and finally daily aggregation
- **Currency conversion**: USD conversion occurs during the normalization step using end-of-day price feeds matched by date, token address, and chain
- **Time aggregation**: Daily boundaries are established by truncating block timestamps to day precision, with all trades within a 24-hour period counted together
- **Final calculation**: The final trade count represents the number of distinct transaction hashes that executed swaps on SolidLizard pairs each day. The `finalize_metric_trade_count` macro standardizes the output format and applies zero-filling for days with no trading activity to maintain complete time series continuity.

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

Number of trades executed on a decentralized exchange.

SolidLizardSLIZ

Trade count

Trade count

Competitive landscape