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

LFJ (previously Trader Joe) is a non-custodial exchange protocol built on Avalanche (originally a fork of SushiSwap). LFJ was founded by an anonymous team and launched in 2021.

JOE tokenholders own and govern the protocol. They currently take a cut of the total trading fees paid by traders (revenue). LFJ's investors include Three Arrows Capital, DeFiance Capital, GBV Capital, Mechanism Capital, etc.

website

github

twitter

discord

etherscan

Exchanges (DEX)

# LFJ Tradeable pairs Methodology

## 1. Overview

The tradeable pairs metric measures the cumulative count of unique trading pairs available on TraderJoe DEX across multiple blockchain networks. This metric tracks the total number of distinct token pairs that have ever been created on the platform, providing insight into the protocol's liquidity infrastructure growth over time. The calculation aggregates pair creation events from multiple TraderJoe contract versions and computes a running total that increases whenever new trading pairs are deployed.

## 2. Data sources

The calculation relies on the following raw data sources:

- **Pair creation events**: Parsed `PairCreated` events from TraderJoe V1 factory contracts on Avalanche and BSC networks
- **Liquidity book pair creation events**: Parsed `LBPairCreated` events from TraderJoe V2 LBFactory contracts across Arbitrum, BSC, Avalanche, and Ethereum networks  
- **Updated factory events**: Parsed `LBPairCreated` events from TraderJoe V2.1 (LBFactoryV2) contracts on Ethereum, Arbitrum, BSC, and Avalanche
- **Latest factory events**: Parsed `LBPairCreated` events from TraderJoe V2.2 (LBFactoryV22) contracts on Arbitrum and Avalanche
- **Token metadata**: Token registry data containing decimal precision and symbol information for pair identification and naming

## 3. Step-by-step calculation

### Component A: Pair creation event extraction
- **Purpose**: Collect all trading pair creation events from multiple TraderJoe contract versions and chains
- **Logic**: Union data from eleven different event sources spanning TraderJoe V1 and V2 factory contracts. Each event contains the addresses of two tokens (`tokenX`/`tokenY` or `token0`/`token1`) and the resulting pair contract address (`LBPair` or `pair`). The events are standardized across different contract versions and chains, with chain and version information added for context.
- **Key fields**: `block_timestamp` for timing, `account_address` for unique pair identification, `token0_address` and `token1_address` for the paired tokens, `chain` and `version` for protocol context

### Component B: Metadata enrichment and pair identification  
- **Purpose**: Enrich pair data with token information and create standardized pair identifiers
- **Logic**: Join pair creation data with token metadata to retrieve decimal precision and symbol information for both tokens in each pair. Generate human-readable pair names by concatenating token symbols. Each unique combination of pair contract address and chain represents a distinct tradeable pair.
- **Key fields**: `token0_decimals` and `token1_decimals` for precision, `account_name` combining token symbols, `account_address` as unique pair identifier

### Component C: First appearance identification
- **Purpose**: Determine when each trading pair was first created to avoid double-counting
- **Logic**: For each unique trading pair identified by `account_address` and `chain`, find the earliest `block_timestamp` when that pair was created. Truncate timestamps to day level to establish daily boundaries for aggregation. This ensures each pair is only counted once regardless of how many creation events may exist.
- **Key fields**: `timestamp` truncated to day level, `chain` for partitioning, `account_address` for unique pair identification

### Component D: Daily aggregation with gap filling
- **Purpose**: Count new pairs created each day and ensure continuous time series
- **Logic**: Group first appearances by day and chain, counting distinct pair addresses to determine how many new tradeable pairs were created on each date. Apply zero-filling logic to insert missing dates with zero pair counts, ensuring a continuous daily time series without gaps between the first and last pair creation dates on each chain.
- **Key fields**: `pair_count` representing new pairs created each day, filled with zeros for missing dates

### Final aggregation
- **Combining components**: The daily new pair counts are processed through a cumulative sum calculation
- **Time aggregation**: Daily boundary logic based on `block_timestamp` truncation to day level  
- **Final calculation**: Apply a window function with running sum partitioned by `chain` and ordered by `timestamp` to create a cumulative count. This produces the total number of tradeable pairs that have ever existed on each chain up to any given date. The result represents the protocol's growing liquidity infrastructure over time, with separate totals maintained for each blockchain network where TraderJoe operates.

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

Number of unique token pairs available for trading on the exchange.

LFJJOE

Tradeable pairs

Tradeable pairs

Competitive landscape

Chain breakdown