# Calculate Token Amounts

Calculate the exact token amounts required for each bin based on your liquidity distribution. Essential for preparing transactions and avoiding slippage.

### Token Requirements by Bin

DLMM requires different token ratios based on bin position:

* **Below active bin**: 100% token Y (quote token)
* **At active bin**: Both tokens (ratio depends on position in bin)
* **Above active bin**: 100% token X (base token)

### Basic Calculation

```typescript
import { getAmountXFromLiquidity, getAmountYFromLiquidity } from '@ferra-labs/dlmm';

// For a specific bin
const binId = 8388610;
const liquidity = 1000000n;
const binPrice = getPriceFromBinId(binId, binStep);

// Calculate required amounts
const amountX = getAmountXFromLiquidity(liquidity, 0n, binPrice);
const amountY = getAmountYFromLiquidity(liquidity, amountX, binPrice);

console.log(`Bin ${binId} needs:`, {
  tokenX: amountX,
  tokenY: amountY
});
```

### Multi-Bin Calculation

```typescript
// Calculate for distribution across bins
function calculateTokensForDistribution(
  pair: LBPair,
  deltaIds: number[],
  distribution: number[],
  totalLiquidity: bigint
) {
  let totalX = 0n;
  let totalY = 0n;
  
  deltaIds.forEach((delta, i) => {
    const binId = pair.parameters.active_id + delta;
    const binLiquidity = (totalLiquidity * BigInt(distribution[i])) / 100n;
    
    if (delta < 0) {
      // Below active - only Y needed
      totalY += binLiquidity;
    } else if (delta > 0) {
      // Above active - only X needed
      totalX += binLiquidity;
    } else {
      // Active bin - both needed (simplified 50/50)
      totalX += binLiquidity / 2n;
      totalY += binLiquidity / 2n;
    }
  });
  
  return { totalX, totalY };
}
```

### Using SDK Helpers

```typescript
// Preview before adding liquidity
const pair = await sdk.Pair.getPair(pairAddress);
const bins = await sdk.Pair.getPairBins(pair, [activeId - 5, activeId + 5]);

// Check current reserves
bins.forEach((bin, index) => {
  const binId = activeId - 5 + index;
  console.log(`Bin ${binId}:`, {
    currentX: bin.reserve_x,
    currentY: bin.reserve_y
  });
});
```

### Active Bin Calculation

For the active bin, token ratio depends on position within the bin:

```typescript
// Simplified active bin calculation
function getActiveBinAmounts(
  totalLiquidity: bigint,
  currentPrice: number
) {
  // Price determines ratio (simplified)
  // Real calculation uses bin position
  const ratio = currentPrice / (1 + currentPrice);
  
  const amountX = (totalLiquidity * BigInt(Math.floor(ratio * 1000))) / 1000n;
  const amountY = totalLiquidity - amountX;
  
  return { amountX, amountY };
}
```

### Practical Example

```typescript
// Planning liquidity for ETH/USDC
const activeId = pair.parameters.active_id;
const distribution = {
  deltaIds: [-2, -1, 0, 1, 2],
  weights: [20, 20, 20, 20, 20]  // Even distribution
};

// Calculate requirements
const required = calculateTokensForDistribution(
  pair,
  distribution.deltaIds,
  distribution.weights,
  parseEther("1")  // 1 ETH worth of liquidity
);

console.log("Need to prepare:", {
  ETH: formatEther(required.totalX),
  USDC: formatUnits(required.totalY, 6)
});
```

### Important Notes

* Always add buffer for slippage (1-2%)
* Active bin requirements change with price
* Use current bin reserves for accurate calculation
* Consider gas costs for many bins

### Common Patterns

```typescript
// Add 5% buffer for safety
const buffer = 1.05;
const safeAmountX = totalX * BigInt(Math.ceil(buffer * 100)) / 100n;
const safeAmountY = totalY * BigInt(Math.ceil(buffer * 100)) / 100n;
```

### Related Topics

* [Add Liquidity Overview](https://docs.ferra.ag/integration/dlmm/typescript-sdk/add-liquidity/add-liquidity-overview) - Understanding requirements
* [SPOT Distribution](https://docs.ferra.ag/integration/dlmm/typescript-sdk/add-liquidity/spot-distribution) - Simple calculations
* [Slippage Protection](https://docs.ferra.ag/integration/dlmm/typescript-sdk/swap-operations/slippage-protection) - Handle price changes