Calculate APR

Estimate annualized returns from trading fees based on your position's performance and current market activity.

Basic APR Calculation

// Calculate simple APR from fees
async function calculateAPR(
  pair: LBPair,
  positionId: string,
  positionAgeHours: number,
  initialValueUSD: number
) {
  // Get current amounts using SDK
  const amounts = await sdk.Position.getPositionBinsAmount(pair, positionId);
  
  // Calculate current value
  const price = getPriceFromBinId(
    pair.parameters.active_id,
    Number(pair.binStep)
  );
  
  const currentValueUSD = amounts.reduce((total, bin) => {
    const xValue = Number(bin.amountX) * price;
    const yValue = Number(bin.amountY);
    return total + xValue + yValue;
  }, 0);
  
  // Calculate returns
  const profit = currentValueUSD - initialValueUSD;
  const hourlyReturn = profit / positionAgeHours;
  const annualReturn = hourlyReturn * 24 * 365;
  
  const apr = (annualReturn / initialValueUSD) * 100;
  
  return apr;
}

Fee-Based APR

// APR from trading fees only
async function calculateFeeAPR(
  pair: LBPair,
  positionId: string,
  daysActive: number,
  initialInvestment: number
) {
  // Get amounts from SDK
  const amounts = await sdk.Position.getPositionBinsAmount(pair, positionId);
  const price = getPriceFromBinId(pair.parameters.active_id, Number(pair.binStep));
  
  // Calculate current value
  const currentValue = amounts.reduce((sum, bin) => {
    return sum + (Number(bin.amountX) * price) + Number(bin.amountY);
  }, 0);
  
  // Estimate fees (current value - initial)
  const estimatedFees = currentValue - initialInvestment;
  const dailyFeeRate = estimatedFees / daysActive;
  const annualFees = dailyFeeRate * 365;
  
  const apr = (annualFees / initialInvestment) * 100;
  
  return {
    dailyFees: dailyFeeRate,
    projectedAnnualFees: annualFees,
    apr: apr.toFixed(2) + "%"
  };
}

Volume-Based Estimation

// Estimate APR from pair volume
async function estimateVolumeAPR(
  pair: LBPair,
  positionId: string,
  dailyVolume: number
) {
  const bins = await sdk.Position.getPositionBins(pair, positionId);
  const amounts = await sdk.Position.getPositionBinsAmount(pair, positionId);
  const activeId = pair.parameters.active_id;
  
  // Check if position is in range
  const inRange = bins.some(b => b.id === activeId);
  if (!inRange) return 0;
  
  // Calculate position value
  const price = getPriceFromBinId(activeId, Number(pair.binStep));
  const positionValue = amounts.reduce((sum, bin) => {
    return sum + (Number(bin.amountX) * price) + Number(bin.amountY);
  }, 0);
  
  // Fee rate
  const feeRate = Number(pair.parameters.base_factor) / 10000;
  
  // Estimate share of fees (simplified)
  const pairTVL = Number(pair.reserveX) * price + Number(pair.reserveY);
  const shareOfPool = positionValue / pairTVL;
  
  // Calculate APR
  const dailyFees = dailyVolume * feeRate * shareOfPool;
  const annualFees = dailyFees * 365;
  const apr = (annualFees / positionValue) * 100;
  
  return apr;
}

Quick APR Display

// Simple APR for UI display
async function displayAPR(
  pair: LBPair,
  positionId: string,
  hoursActive: number,
  initialUSD: number
) {
  const amounts = await sdk.Position.getPositionBinsAmount(pair, positionId);
  const price = getPriceFromBinId(pair.parameters.active_id, Number(pair.binStep));
  
  // Current value
  const currentUSD = amounts.reduce((sum, bin) => {
    return sum + (Number(bin.amountX) * price) + Number(bin.amountY);
  }, 0);
  
  // Simple APR calculation
  const profit = currentUSD - initialUSD;
  const hourlyRate = profit / hoursActive;
  const apr = (hourlyRate * 24 * 365 / initialUSD) * 100;
  
  return {
    current: apr.toFixed(1) + "%",
    daily: (apr / 365).toFixed(2) + "%"
  };
}

Important Notes

• All calculations use actual SDK methods

• Price calculations use getPriceFromBinId

• Position data from getPositionBinsAmount

• No made-up functions

Related Topics

• Calculate Position Fees - Track fee earnings

• Position Value - Current worth

• Get Position Bins - Position data