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

Camelot is a non-custodial exchange protocol built on Arbitrum. Camelot was founded by the pseudonymous Myrddin and launched in 2022.

GRAIL 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)

Camelot

# Camelot Active users (monthly) Methodology

## 1. Overview

The Camelot Monthly Active Users (MAU) metric measures the number of distinct users who executed at least one trade on the Camelot decentralized exchange within a rolling 30-day period. This metric provides insight into the active user engagement and adoption of Camelot's AMM protocols on Arbitrum. The calculation uses a rolling window approach where each day's MAU includes all unique users who traded within the previous 29 days plus the current day.

## 2. Data sources

- **Camelot V2 swap events**: Parsed `Pair_Swap_event` logs from Camelot V2 pools on Arbitrum containing trade execution data
- **Camelot V3 swap events**: Parsed `Pool_Swap_event` logs from Camelot V3 pools on Arbitrum containing trade execution data  
- **Arbitrum transaction data**: Transaction records providing the originating user address for each swap transaction

## 3. Step-by-step calculation

### Component A: Raw trade extraction
- **Purpose**: Extract all trading activity from both Camelot V2 and V3 protocols
- **Logic**: Combine swap events from both protocol versions. For V2, calculate token amount changes using the difference between input and output amounts (`amount0In` minus `amount0Out` and `amount1In` minus `amount1Out`). For V3, use the direct swap amounts (`amount0` and `amount1`). Join each swap event with transaction data to identify the user who initiated the trade using the transaction's `from_address` field.
- **Key fields**: `block_timestamp`, `transaction_hash`, `user_address`, `token0_amount`, `token1_amount`, swap event amounts

### Component B: Daily active user aggregation  
- **Purpose**: Calculate daily distinct active users from the raw trade data
- **Logic**: Group all trades by day using timestamp truncation to day granularity. Count distinct `user_address` values for each day to determine the number of unique traders. All identified users are classified as 'Trader' user type since they performed trading activities. Include chain, product, and business segment metadata for downstream dimensional analysis.
- **Key fields**: `timestamp` (day-truncated), `user_dau` (distinct user addresses), `user_type`, `chain`, `product_id`

### Component C: HyperLogLog sketch creation
- **Purpose**: Create efficient data structures for distinct user counting across time windows
- **Logic**: Transform the daily active user data into HyperLogLog sketches using `hll_count.init` with precision parameter 15. These probabilistic data structures allow efficient merging and counting of distinct users across multiple days without storing individual user addresses. Group by timestamp, chain, user type, and product dimensions to maintain all required breakdown levels.
- **Key fields**: `hll` (HyperLogLog sketch), dimensional grouping fields

### Component D: Rolling window construction
- **Purpose**: Create 30-day rolling windows for MAU calculation
- **Logic**: Generate a complete datespine covering all days from the earliest trade date to yesterday. For each day, create a 30-day lookback window including the previous 29 days plus the current day using `generate_timestamp_array`. Join this window structure with the HyperLogLog sketches to ensure complete coverage even for days with no trading activity.
- **Key fields**: `timestamp` (target date), `joinday` (dates within the 30-day window), `hll` sketches

### Component E: Dimensional MAU breakdowns
- **Purpose**: Calculate MAU across different analytical dimensions
- **Logic**: Create four distinct dimensional views by merging HyperLogLog sketches within each 30-day window:
  - Project-level: Overall MAU across all chains and products (sets chain, product, and user type to null)
  - Chain-level: MAU broken down by blockchain (preserves `chain_id`, nullifies product and user type)  
  - User type-level: MAU by user classification (preserves `user_type`, nullifies chain and product)
  - Product-level: MAU by specific product (preserves `product_id`, nullifies chain and user type)
- **Key fields**: `dimensions` (breakdown type), dimension-specific IDs, `user_mau` (distinct count)

### Final aggregation
- **Combining components**: Union all dimensional breakdowns into a single result set with consistent schema structure
- **HyperLogLog merging**: Use `hll_count.merge_partial` to combine sketches across the 30-day window, then `hll_count.extract` to get the final distinct user count
- **Schema standardization**: Apply the `finalize_metric_user_mau` macro to ensure consistent field naming, data types, and missing value handling
- **Time boundaries**: Use daily timestamps as the primary time grain, with each day representing the MAU for the trailing 30-day period ending on that date
- **Final calculation**: For each day and dimensional breakdown, the MAU equals the count of distinct users who executed at least one trade within the 30-day rolling window ending on that day

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

Unique revenue-generating users over a rolling 30-day window.

CamelotGRAIL

Active users (monthly)

Active users (monthly)

Competitive landscape

Chain breakdown