# How Meteora Dynamic Bonding Curve Implements the 90/10 Creator Fee Split

> Discover how Meteora Dynamic Bonding Curve implements the 90/10 creator fee split by allocating 10% to creators and 90% to the treasury via DbcConfigParams.

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

---

**Meteora's Dynamic Bonding Curve allocates 10% of every swap fee to the token creator by setting `creatorTradingFeePercent` to 10 in the `DbcConfigParams` configuration, while the remaining 90% is routed to the protocol treasury.**

The Meteora Dynamic Bonding Curve (DBC) SDK provides a configurable fee structure that allows token launchers to reward creators from ongoing trading activity. In the CloddsBot repository, this mechanism is implemented through strict TypeScript interfaces that wrap the Solana program's instruction builders, ensuring the 90/10 split is enforced at the protocol level during pool initialization.

## Configuration Parameters in DbcConfigParams

The fee split is defined in the `DbcConfigParams` structure within [`src/solana/meteora-dbc.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/meteora-dbc.ts). This interface exposes two critical fields that control creator economics:

- **`creatorTradingFeePercent`** – Defaults to `10`, representing the percentage of total swap fees diverted to the creator's vault. With the protocol taking the remainder, this yields the advertised 90/10 split【file:/cache/repos/github.com/alsk1992/CloddsBot/main/src/solana/meteora-dbc.ts†L124-L132】.
- **`creatorLiquidityPct`** – Defaults to `5`, granting the creator an immediate 5% share of the initial liquidity minted to the pool【file:/cache/repos/github.com/alsk1992/CloddsBot/main/src/solana/meteora-dbc.ts†L125-L129】.

These values are not hardcoded constants but configurable parameters passed through the `buildConfigParams` helper, allowing flexibility while maintaining the default 90/10 revenue model.

## Encoding the Fee Split On-Chain

When a pool is created, the `buildConfigParams` function translates the JavaScript configuration into Solana instruction data. The SDK method `buildCurveWithMarketCap` receives these parameters and encodes them into the on-chain pool state, permanently setting the fee distribution logic within the Meteora program account【file:/cache/repos/github.com/alsk1992/CloddsBot/main/src/solana/meteora-dbc.ts†L180-L191】.

This encoding happens atomically during the creation transaction. Once the pool is live, every subsequent swap automatically routes 10% of the collected fees to the creator's associated token account while the protocol retains the 90% balance.

## HTTP API Exposure

CloddsBot exposes this functionality through its gateway layer. The `/launch` endpoint defined in [`src/gateway/launch-routes.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/gateway/launch-routes.ts) accepts creator-fee parameters from HTTP clients and forwards them to the DBC builder【file:/cache/repos/github.com/alsk1992/CloddsBot/main/src/gateway/launch-routes.ts†L7-L9】.

This architecture enables external applications to launch tokens with the 90/10 split using a single API call, abstracting away the complexity of direct Solana transaction construction.

## Implementation Example

The following TypeScript demonstrates how to instantiate a pool with the standard 90/10 creator fee split and 5% initial liquidity allocation:

```typescript
import {
  createDbcPool,
  DbcPoolParams,
  DbcConfigParams,
} from '@/solana/meteora-dbc';

// Configure the 90/10 fee split
const config: DbcConfigParams = {
  // 10% of swap fees to creator (90% to protocol)
  creatorTradingFeePercent: 10,
  // 5% of initial liquidity to creator
  creatorLiquidityPct: 5,
};

const poolParams: DbcPoolParams = {
  name: 'Meteora Token',
  symbol: 'MTK',
  uri: 'https://example.com/metadata.json',
  config,
};

// Deploy pool and config in one transaction
const { poolAddress, configAddress, signature } = await createDbcPool(
  connection,
  creatorKeypair,
  poolParams,
);

console.log(`Pool: ${poolAddress}`);
console.log(`Config: ${configAddress}`);

```

The `createDbcPool` function orchestrates the entire flow: it invokes `buildConfigParams` to prepare the fee structure, then calls the Meteora SDK to write the data on-chain, returning the pool and configuration addresses once the transaction confirms.

## Summary

- The **90/10 split** is achieved by setting `creatorTradingFeePercent` to `10` in `DbcConfigParams`, leaving 90% for the protocol.
- Default configuration values reside in [`src/solana/meteora-dbc.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/meteora-dbc.ts), with `creatorLiquidityPct` set to `5` for initial creator ownership.
- The **`buildCurveWithMarketCap`** SDK method encodes fee parameters into the on-chain pool account during initialization.
- **`createDbcPool`** provides a high-level wrapper that handles transaction building and submission.
- HTTP endpoints in **[`src/gateway/launch-routes.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/gateway/launch-routes.ts)** expose the functionality to external clients via the `/launch` route.

## Frequently Asked Questions

### What does the `creatorTradingFeePercent` parameter control?

The `creatorTradingFeePercent` field in `DbcConfigParams` determines the portion of every swap fee allocated to the token creator. In CloddsBot, this defaults to `10`, meaning creators earn 10% of all trading fees while the protocol receives 90%. This value is passed directly to the Meteora DBC SDK during pool creation.

### How is the initial creator liquidity share configured?

The `creatorLiquidityPct` parameter specifies the percentage of pool liquidity minted to the creator's address when the pool is initialized. CloddsBot defaults this to `5`, granting creators immediate ownership of 5% of the liquidity supply before trading begins, independent of the ongoing fee split.

### Where does the fee split get encoded on-chain?

The split is encoded within the `buildConfigParams` helper function in [`src/solana/meteora-dbc.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/solana/meteora-dbc.ts). This function invokes `buildCurveWithMarketCap`, which writes the `creatorTradingFeePercent` and `creatorLiquidityPct` values into the Meteora program's pool configuration account, making the fee distribution immutable and enforceable by the smart contract.

### Can the fee split be modified after pool creation?

Based on the CloddsBot implementation, fee parameters are immutable once the pool is created. The `DbcConfigParams` must be finalized before calling `createDbcPool`, as the Meteora DBC program stores these values in the on-chain config account during the initialization transaction. To change the split, developers must deploy a new pool with updated parameters.