Fee Structure

Understand how trading fees work in DLMM's bin-based system, including fee accumulation, distribution to liquidity providers, and protocol revenue sharing.

How Fees Work in DLMM

Trading fees in DLMM:

• Charged on each swap

• Accumulate in the bins used

• Distributed proportionally to LPs

• Include base + variable components

Swap → Fee charged → Stored in bins → LPs collect share

Fee Components

Base Fee

interface PairParameters {
  base_factor: string;     // Base fee rate (e.g., 3000 = 0.3%)
  protocol_share: string;  // Protocol's share (e.g., 1000 = 10%)
}

// Example: 0.3% base fee
const baseFeePercent = Number(pair.parameters.base_factor) / 10000;

Variable Fee

Adjusts based on volatility:

// Increases during high volatility
// Decreases during stable periods
const variableFee = calculateVariableFee(
  pair.parameters.volatility_accumulator,
  pair.parameters.max_volatility_accumulator
);

const totalFee = baseFee + variableFee;

Fee Accumulation in Bins

// Fees stored separately from reserves
interface BinReserves {
  reserve_x: bigint;    // Trading liquidity
  reserve_y: bigint;    // Trading liquidity
  fee_x: bigint;        // Accumulated fees
  fee_y: bigint;        // Accumulated fees
}

// Total bin value = reserves + fees
const totalX = bin.reserve_x + bin.fee_x;
const totalY = bin.reserve_y + bin.fee_y;

LP Fee Share Calculation

// Your share of fees in a bin
function calculateLPFeeShare(
  yourLiquidity: bigint,
  totalSupply: bigint,
  binFees: { fee_x: bigint, fee_y: bigint }
): { feeX: bigint, feeY: bigint } {
  const feeX = (yourLiquidity * binFees.fee_x) / totalSupply;
  const feeY = (yourLiquidity * binFees.fee_y) / totalSupply;
  
  return { feeX, feeY };
}

Protocol Revenue

// Protocol takes a percentage of fees
function calculateProtocolFee(
  swapFee: bigint,
  protocolShare: number // basis points
): bigint {
  return (swapFee * BigInt(protocolShare)) / 10000n;
}

// Example: 10% protocol share of 0.3% swap fee
const swapAmount = parseEther("100");
const swapFee = (swapAmount * 30n) / 10000n; // 0.3%
const protocolFee = (swapFee * 1000n) / 10000n; // 10% of fee
const lpFee = swapFee - protocolFee; // 90% to LPs

Fee Tiers by Pair Type

Common configurations:

Pair Type	Base Fee	Typical Range
Stable	0.01%	0.01-0.05%
Correlated	0.05%	0.05-0.10%
Blue-chip	0.20%	0.20-0.30%
Volatile	0.30%	0.30-5.00%

Viewing Pair Fees

// Check current fee parameters
const pair = await sdk.Pair.getPair(pairAddress);

const feeInfo = {
  baseFee: Number(pair.parameters.base_factor) / 100, // basis points to percent
  protocolShare: Number(pair.parameters.protocol_share) / 100,
  currentVolatility: pair.parameters.volatility_accumulator
};

console.log(`Base fee: ${feeInfo.baseFee}%`);
console.log(`Protocol takes: ${feeInfo.protocolShare}% of fees`);

Fee Collection Process

Fees are collected automatically when:

1. Removing liquidity - Proportional share included

2. Closing position - All fees withdrawn

3. No separate claim - Unlike some protocols

// Fees included in removal
const removal = await sdk.Position.getPositionBinsAmount(pair, positionId);

removal.forEach(bin => {
  // amountX and amountY already include fees
  console.log(`Bin ${bin.id}: Includes accumulated fees`);
});

Estimating Fee Income

// Estimate daily fees for a position
async function estimateDailyFees(
  pair: LBPair,
  positionId: string,
  dailyVolume: bigint
): Promise<bigint> {
  const bins = await sdk.Position.getPositionBins(pair, positionId);
  const activeId = pair.parameters.active_id;
  
  // Assume volume concentrates around active bin
  const activeBin = bins.find(b => b.id === activeId);
  if (!activeBin) return 0n;
  
  const baseFee = BigInt(pair.parameters.base_factor);
  const yourShare = activeBin.liquidity; // Simplified
  
  // Rough estimate
  return (dailyVolume * baseFee * yourShare) / (10000n * totalLiquidity);
}

Key Points

• Fees accumulate in bins, not positions

• Automatically collected on withdrawal

• Base + variable fee structure

• Protocol takes percentage of fees

• Higher volatility = higher fees

Related Topics

• Calculate Position Fees - Track your earnings

• Collect Fees - Claim accumulated fees

• Calculate APR - Fee-based returns

• Get Pair Reserves - View fee accumulation