# How Anti-Sniper Starting-Fee Decay Works in Meteora Dynamic Bonding Curve

> Discover how Meteora Dynamic Bonding Curve uses anti-sniper starting fee decay. Learn about the exponential algorithm that lowers swap fees over time, protecting traders from rapid price manipulation.

- Repository: [AL/CloddsBot](https://github.com/alsk1992/CloddsBot)
- Tags: deep-dive
- Published: 2026-09-13

---

**Meteora’s Dynamic Bonding Curve implements anti-sniper protection through an exponential decay algorithm that gradually reduces swap fees from a high starting basis point value to a minimum floor over a configurable time window.**

The **Meteora Dynamic Bonding Curve (DBC)** protects new liquidity pools from front-running bots by charging elevated fees immediately after launch that decay to stable rates. In the **CloddsBot** codebase, this mechanism is orchestrated through TypeScript modules that calculate time-weighted fee reductions based on slot-based elapsed time.

## Configuration Parameters in the Meteora DBC Skill

The anti-sniper parameters are defined in [`src/skills/bundled/meteora-dbc/index.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/skills/bundled/meteora-dbc/index.ts) when the DBC-based pool is queried. The skill constructs a `MeteoraDlmmQuote` request containing three critical fee-related settings:

- **`startingFeeBps`**: The initial fee expressed in basis points (bps), applied immediately after pool creation to deter snipers.
- **`minimumFeeBps`**: The floor fee that serves as the lower bound; the decaying fee never falls below this value.
- **`feeDecayPeriod`**: The duration, measured in slots, over which the fee transitions from the starting value to the minimum.

These values are injected into the quote request at line 151 of the skill file, ensuring every price calculation accounts for the pool's maturity level.

## The Exponential Decay Formula Implementation

The actual decay calculation resides in [`src/solana/meteora.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/meteora.ts), where the `getMeteoraDlmmQuote` function computes the effective fee based on elapsed blockchain slots. The implementation uses an exponential decay formula:

```typescript
const elapsed = currentSlot - pool.creationSlot;
const decayFactor = Math.exp(-elapsed / feeDecayPeriod);
const feeBps = Math.max(
  minimumFeeBps,
  Math.round(startingFeeBps * decayFactor)
);

```

The logic operates through three steps:

1. **Elapsed Time Calculation**: Subtracts the pool's `creationSlot` from the `currentSlot` to determine how many slots have passed since initialization.
2. **Decay Factor Computation**: Applies `Math.exp(-elapsed / feeDecayPeriod)` to generate an exponential decay multiplier approaching zero as time progresses.
3. **Floor Enforcement**: Uses `Math.max` to ensure the calculated fee respects the `minimumFeeBps` threshold, preventing fees from dropping below the configured floor even after extended decay periods.

## Integration with Arbitrage Scanning

When the bot evaluates arbitrage opportunities, it invokes `getMeteoraDlmmQuote` from [`src/trading/venue-arbitrage-scanner.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/trading/venue-arbitrage-scanner.ts). The function automatically applies the anti-sniper decay logic, returning a `sellQuote` object where the `feeBps` property reflects the decay-adjusted rate:

```typescript
const quote = await deps.getMeteoraDlmmQuote(ctx.connection, {
  mintA: baseMint,
  mintB: quoteMint,
  amount: baseAmount.toString(),
  // startingFeeBps, minimumFeeBps, and feeDecayPeriod 
  // are injected by the Meteora-DBC skill context
});

```

This integration ensures that arbitrage calculations account for the actual trading costs imposed by the anti-sniper mechanism, protecting profit calculations from fee surprises as pools mature.

## Practical Code Examples

### Fetching a Quote with Anti-Sniper Fee Decay

```typescript
import { getMeteoraDlmmQuote } from '@/solana/meteora';

async function fetchQuote(
  conn: Connection,
  baseMint: string,
  quoteMint: string,
  amount: number
) {
  const quote = await getMeteoraDlmmQuote(conn, {
    mintA: baseMint,
    mintB: quoteMint,
    amount: amount.toString(),
    // Parameters injected by Meteora-DBC skill:
    // startingFeeBps, minimumFeeBps, feeDecayPeriod
  });
  
  console.log('Effective fee (bps):', quote.feeBps);
  console.log('Amount out:', quote.outAmount);
  return quote;
}

```

### Manual Fee-Decay Calculation

For testing or simulation purposes, you can calculate the anti-sniper fee independently:

```typescript
function calculateAntiSniperFee(
  startingFeeBps: number,
  minimumFeeBps: number,
  feeDecayPeriod: number,
  elapsedSlots: number
): number {
  const decay = Math.exp(-elapsedSlots / feeDecayPeriod);
  return Math.max(
    minimumFeeBps,
    Math.round(startingFeeBps * decay)
  );
}

// Example: 500 bps start, 30 bps minimum, decay over 10,000 slots
// After 2,000 slots:
const fee = calculateAntiSniperFee(500, 30, 10_000, 2_000);
console.log(`Current fee: ${fee} bps`); // Output: ~410 bps

```

## Summary

- The anti-sniper mechanism uses **exponential decay** to reduce fees from `startingFeeBps` to `minimumFeeBps` over a `feeDecayPeriod` measured in Solana slots.
- Configuration resides in **[`src/skills/bundled/meteora-dbc/index.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/skills/bundled/meteora-dbc/index.ts)**, while the decay formula executes in **[`src/solana/meteora.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/meteora.ts)**.
- The **`getMeteoraDlmmQuote`** function automatically applies decay calculations, ensuring arbitrage scanners in **[`src/trading/venue-arbitrage-scanner.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/trading/venue-arbitrage-scanner.ts)** receive accurate fee estimates.
- Fees are protected by a hard floor via **`Math.max`**, guaranteeing they never drop below `minimumFeeBps` regardless of pool age.

## Frequently Asked Questions

### How is the elapsed time calculated for the fee decay?

The elapsed time is computed by subtracting the pool's `creationSlot` from the current blockchain slot, as captured in the [`meteora.ts`](https://github.com/alsk1992/CloddsBot/blob/main/meteora.ts) wrapper. This slot-based approach ensures deterministic, on-chain verifiable timing rather than relying on wall-clock time.

### What prevents the fee from dropping below the intended minimum?

The decay formula explicitly wraps the calculation in `Math.max(minimumFeeBps, ...)`, ensuring that even as the exponential decay factor approaches zero, the fee cannot fall below the configured `minimumFeeBps` value defined in the DBC skill parameters.

### Can the decay period be adjusted for different liquidity pools?

Yes, the `feeDecayPeriod` is a configurable parameter passed through the `MeteoraDlmmQuote` request in [`src/skills/bundled/meteora-dbc/index.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/skills/bundled/meteora-dbc/index.ts). Different pools can specify distinct decay durations based on their specific anti-sniper requirements and expected trading patterns.

### How does this mechanism protect against front-running bots?

By setting a high `startingFeeBps` immediately after pool creation, the mechanism imposes prohibitive costs on bots attempting to snipe initial liquidity. As the `feeDecayPeriod` progresses and legitimate trading stabilizes, the fee decays to `minimumFeeBps`, allowing normal market participation while the pool matures.