Liquidity providers deposit funds into Ramses and stake their LP tokens to receive RAM tokens in proportion to their share of the votes (token incentives).

Ramses is a non-custodial exchange protocol built on Arbitrum. Ramses was founded by pseudonyms Dog and North in 2023.

RAM tokenholders own and govern the protocol. They vote which pools they wish to earn trading fees from (revenue).

github

twitter

discord

etherscan

website

Exchanges (DEX)

Ramses Exchange

# Ramses Exchange Average trading volume (per user) Methodology

## 1. Overview

Trading volume per daily active user measures the average USD value of trades executed per unique user on the Ramses decentralized exchange. This metric helps assess user engagement intensity by dividing the total daily trading volume by the number of unique users who executed at least one trade that day. The calculation combines swap event data from both Ramses v1 (Legacy Pairs) and v2 (Concentrated Liquidity Pools) deployed on Arbitrum.

## 2. Data sources

The calculation relies on several key data sources:

- **Ramses swap events**: Parsed `Swap` events from Ramses v1 Legacy Pair contracts and v2 Pool contracts on Arbitrum
- **Arbitrum transaction data**: Transaction records to map contract interactions back to actual user addresses
- **Trading pair metadata**: Parsed `PairCreated` and `PoolCreated` events from Ramses factory contracts to identify valid trading pairs and their token compositions
- **Token metadata**: Token symbol and decimal information for proper amount normalization
- **End-of-day price feeds**: Token price data for USD conversion, with special CoinGecko price feeds for the RAM token
- **Factory events**: Contract deployment events that define the relationship between trading pairs and their underlying tokens

## 3. Step-by-step calculation

### Component A: Raw trade extraction
- **Purpose**: Extract and standardize swap events from both Ramses protocol versions
- **Logic**: Parse `Swap` events from Ramses v1 Legacy Pair contracts and v2 Pool contracts on Arbitrum. For v1 trades, calculate net token movements by taking the difference between `amount0In` minus `amount0Out` and `amount1In` minus `amount1Out`. For v2 trades, use the direct `amount0` and `amount1` values. Join with Arbitrum transaction data to map the `sender` field (which represents the contract address) to the actual `user_address` from the transaction's `from_address` field. Filter to include only trades after the protocol launch date of March 14, 2023.
- **Key fields**: `block_timestamp`, `transaction_hash`, `log_index`, contract `address`, `sender` (contract user), actual `user_address`, `token0_amount`, `token1_amount`

### Component B: Trading pair enrichment
- **Purpose**: Add token metadata and decimal information to enable proper amount calculations
- **Logic**: Combine trade data with trading pair information derived from factory contract events. Use `PairCreated` events from v1 factory and `PoolCreated` events from v2 factory to map each trading pair address to its underlying `token0_address` and `token1_address`. Join with token metadata to retrieve decimal values and symbols for both tokens in each pair. Create trading pair names by concatenating token symbols.
- **Key fields**: `chain`, `product_id` (Legacy Pair or Concentrated Liquidity Pool), `version`, `account_address`, `token0_address`, `token1_address`, `token0_decimals`, `token1_decimals`, `account_name`

### Component C: Amount normalization
- **Purpose**: Convert raw token amounts to human-readable decimals
- **Logic**: Truncate timestamps to daily boundaries for aggregation. Take absolute values of token amounts to handle directional differences between buy and sell trades. Normalize amounts by dividing by 10 raised to the power of each token's decimal count (e.g., dividing by 10^18 for tokens with 18 decimals).
- **Key fields**: `timestamp` (daily), `token0_amount` (normalized), `token1_amount` (normalized)

### Component D: USD conversion with anti-manipulation filter
- **Purpose**: Convert token amounts to USD values while preventing price manipulation attacks
- **Logic**: Join normalized amounts with end-of-day price feeds for both tokens in each pair. For the RAM token specifically, use CoinGecko price data since it lacks standard price feed coverage. Calculate USD values for both `token0_amount` and `token1_amount` by multiplying amounts by their respective USD prices. Apply an anti-manipulation filter by taking the minimum (least) USD value between the two tokens - this prevents artificially inflated trading volumes from price manipulation or oracle attacks. Sum all resulting USD amounts by day, chain, product type, and version.
- **Key fields**: `trading_volume` (sum of minimum USD values), `price_usd` for each token

### Component E: Daily active user counting
- **Purpose**: Count unique users who executed trades each day
- **Logic**: Extract unique `user_address` values from the trade data for each day. Use HyperLogLog (HLL) probabilistic counting functions to efficiently deduplicate users across multiple dimensions. Generate user counts at different aggregation levels including total project-level (`project_dbt_tag`), by chain, by user type (Trader), and by product type. The target metric uses the project-level aggregation (`project_dbt_tag` dimension) to get total daily active users across all Ramses products.
- **Key fields**: `user_dau` (distinct count of users), `dimensions` (aggregation level), `user_type` (Trader)

### Final aggregation
- **Combining components**: Join daily trading volumes with daily active user counts on matching timestamps, using the project-level DAU aggregation
- **Currency conversion**: All amounts are converted to USD using end-of-day price feeds before volume aggregation
- **Time aggregation**: Both components use daily timestamp boundaries, truncating to day-level precision
- **Final calculation**: Divide total daily trading volume by daily active users using safe division (returns null if DAU is zero). The result represents the average USD trading volume per active user for each day. Apply a "fill zeros" strategy to populate missing days with zero values rather than nulls.

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

Average trading volume (per user)

Trading volume divided by daily active users.

Ramses ExchangeRAM

Average trading volume (per user)

Average trading volume (per user)

Competitive landscape