Calculate Pool Metrics
Calculate key performance indicators for liquidity pools.
Quick Start
// Get pool and calculate basic metrics
const pool = await sdk.Pool.getPool(poolId)
// Current price
const price = TickMath.sqrtPriceX64ToPrice(
pool.current_sqrt_price,
9, // decimalsA
6 // decimalsB
)
// TVL in tokens
const tvlA = Number(pool.coinAmountA) / 10**9
const tvlB = Number(pool.coinAmountB) / 10**6
console.log({
price: price.toFixed(4),
tvlSUI: tvlA,
tvlUSDC: tvlB
})Price Calculations
Current Price
import { TickMath } from '@ferra-labs/clmm'
// From sqrt price
const price = TickMath.sqrtPriceX64ToPrice(
pool.current_sqrt_price,
pool.coinTypeA.decimals,
pool.coinTypeB.decimals
)
// From tick index
const priceFromTick = TickMath.tickIndexToPrice(
pool.current_tick_index,
decimalsA,
decimalsB
)Price Range
// Get min/max prices for a position
const position = await sdk.Position.getPositionById(positionId)
const minPrice = TickMath.tickIndexToPrice(
position.tick_lower_index,
decimalsA,
decimalsB
)
const maxPrice = TickMath.tickIndexToPrice(
position.tick_upper_index,
decimalsA,
decimalsB
)
console.log(`Price range: ${minPrice} - ${maxPrice}`)TVL Calculation
Pool TVL
async function calculatePoolTVL(pool: Pool, priceInUSD: number) {
// Get token amounts
const amountA = Number(pool.coinAmountA) / 10**decimalsA
const amountB = Number(pool.coinAmountB) / 10**decimalsB
// Calculate USD values (assuming token B is USD stable)
const tvlB_USD = amountB
const tvlA_USD = amountA * priceInUSD
const totalTVL = tvlA_USD + tvlB_USD
return {
tvl: totalTVL,
breakdown: {
tokenA: { amount: amountA, usd: tvlA_USD },
tokenB: { amount: amountB, usd: tvlB_USD }
}
}
}Position Value
async function calculatePositionValue(positionId: string) {
const position = await sdk.Position.getPositionById(positionId)
const pool = await sdk.Pool.getPool(position.pool)
// Get token amounts from liquidity
const amounts = ClmmPoolUtil.getCoinAmountFromLiquidity(
new BN(pool.current_sqrt_price),
position.tick_lower_index,
position.tick_upper_index,
new BN(position.liquidity),
false
)
const valueA = Number(amounts.coinA) / 10**decimalsA
const valueB = Number(amounts.coinB) / 10**decimalsB
return { valueA, valueB }
}APR Calculations
Fee APR
async function calculateFeeAPR(poolId: string, period = 7) {
// Get historical fees (from your API/indexer)
const historicalFees = await getPoolFees(poolId, period)
// Get current TVL
const pool = await sdk.Pool.getPool(poolId)
const tvl = await calculatePoolTVL(pool, currentPrice)
// Calculate daily average
const avgDailyFees = historicalFees.total / period
// Annualize
const annualFees = avgDailyFees * 365
const feeAPR = (annualFees / tvl.tvl) * 100
return feeAPR
}Total APR with Rewards
async function calculateTotalAPR(poolId: string) {
// Fee APR
const feeAPR = await calculateFeeAPR(poolId)
// Reward APR
const emissions = await sdk.Rewarder.emissionsEveryDay(poolId)
const pool = await sdk.Pool.getPool(poolId)
const tvl = await calculatePoolTVL(pool, currentPrice)
let rewardAPR = 0
if (emissions) {
emissions.forEach(emission => {
const yearlyEmissions = emission.emissions * 365
const emissionValueUSD = yearlyEmissions * tokenPriceUSD
rewardAPR += (emissionValueUSD / tvl.tvl) * 100
})
}
return {
feeAPR,
rewardAPR,
totalAPR: feeAPR + rewardAPR
}
}Volume Metrics
Estimate from Fees
function estimateVolume(fees: number, feeRate: number) {
// Volume = Fees / Fee Rate
const feePercent = feeRate / 1000000 // Convert from basis points
return fees / feePercent
}
// Example: 24h volume from fees
async function get24hVolume(poolId: string) {
const pool = await sdk.Pool.getPool(poolId)
const feeRate = Number(pool.fee_rate)
// Get 24h fees (from your data source)
const fees24h = await get24hFees(poolId)
return estimateVolume(fees24h, feeRate)
}Price Impact
Calculate for Swap
async function calculatePriceImpact(
pool: Pool,
amount: BN,
a2b: boolean,
byAmountIn: boolean
) {
// Get ticks for calculation
const ticks = await sdk.Pool.fetchTicks({
pool_id: pool.poolAddress,
coinTypeA: pool.coinTypeA,
coinTypeB: pool.coinTypeB
})
// Calculate swap result
const result = sdk.Swap.calculateRates({
currentPool: pool,
coinTypeA: pool.coinTypeA,
coinTypeB: pool.coinTypeB,
decimalsA: 9,
decimalsB: 6,
a2b,
byAmountIn,
amount,
swapTicks: ticks
})
return {
priceImpact: result.priceImpactPct,
effectivePrice: calculateEffectivePrice(result),
isExceed: result.isExceed
}
}Liquidity Distribution
Active Liquidity
async function getActiveLiquidity(poolId: string) {
const pool = await sdk.Pool.getPool(poolId)
const currentTick = pool.current_tick_index
// Get positions
const positions = await sdk.Pool.getPositionList(
pool.position_manager.positions_handle
)
// Calculate in-range liquidity
let activeLiquidity = new BN(0)
let totalLiquidity = new BN(0)
positions.data.forEach(pos => {
const liquidity = new BN(pos.liquidity)
totalLiquidity = totalLiquidity.add(liquidity)
if (pos.tick_lower_index <= currentTick &&
currentTick < pos.tick_upper_index) {
activeLiquidity = activeLiquidity.add(liquidity)
}
})
return {
active: activeLiquidity.toString(),
total: totalLiquidity.toString(),
utilization: activeLiquidity.mul(new BN(100)).div(totalLiquidity)
}
}Complete Example
async function getPoolMetrics(poolId: string) {
const pool = await sdk.Pool.getPool(poolId)
// 1. Price metrics
const currentPrice = TickMath.sqrtPriceX64ToPrice(
pool.current_sqrt_price, 9, 6
)
// 2. TVL calculation
const tvl = await calculatePoolTVL(pool, currentPrice.toNumber())
// 3. Volume (24h)
const volume24h = await get24hVolume(poolId)
// 4. APR calculation
const apr = await calculateTotalAPR(poolId)
// 5. Liquidity metrics
const liquidity = await getActiveLiquidity(poolId)
// 6. Fee tier
const feeTier = Number(pool.fee_rate) / 10000 // basis points to percent
return {
price: currentPrice.toFixed(6),
tvl: {
usd: tvl.tvl.toFixed(2),
tokenA: tvl.breakdown.tokenA,
tokenB: tvl.breakdown.tokenB
},
volume24h: volume24h.toFixed(2),
apr: {
fee: apr.feeAPR.toFixed(2),
rewards: apr.rewardAPR.toFixed(2),
total: apr.totalAPR.toFixed(2)
},
liquidity: {
utilization: `${liquidity.utilization}%`,
active: liquidity.active,
total: liquidity.total
},
feeTier: `${feeTier}%`
}
}
// Usage
const metrics = await getPoolMetrics(poolId)
console.log('Pool Metrics:', metrics)Important Notes
TVL calculation requires external price feeds
APR is estimated based on historical data
Volume calculation depends on fee collection data
Price impact varies with liquidity distribution
Metrics should be cached for performance
Consider using indexer for historical data
Last updated