Struct MeteoraDammV2Pool

pub struct MeteoraDammV2Pool {

    pub info: Pool,
    pub cliff_fee_numerator: u64,
    pub base_fee_mode: u8,
    pub first_factor: u16,
    pub second_factor: [u8; 8],
    pub third_factor: u64,
    pub protocol_fee_percent: u8,
    pub referral_fee_percent: u8,
    pub initialized: u8,
    pub variable_fee_control: u32,
    pub bin_step: u16,
    pub last_update_timestamp: u64,
    pub sqrt_price_reference: u128,
    pub volatility_accumulator: u128,
    pub volatility_reference: u128,
    pub activation_point: u64,
    pub activation_type: u8,
    pub liquidity: u128,
    pub sqrt_price: u128,
    pub collect_fee_mode: u8,
    pub protocol_a_fee: u64,
    pub protocol_b_fee: u64,
    pub partner_a_fee: u64,
    pub partner_b_fee: u64,
    pub sqrt_min_price: u128,
    pub sqrt_max_price: u128,
    pub version: u8,
}

Struct to hold data and PoolTrait implementation for Meteora Ammv2/Dammv2 pools.

Fields

info: Pool

cliff_fee_numerator: u64

base_fee_mode: u8

first_factor: u16

second_factor: [u8; 8]

third_factor: u64

protocol_fee_percent: u8

referral_fee_percent: u8

initialized: u8

variable_fee_control: u32

bin_step: u16

last_update_timestamp: u64

sqrt_price_reference: u128

volatility_accumulator: u128

volatility_reference: u128

activation_point: u64

activation_type: u8

liquidity: u128

sqrt_price: u128

collect_fee_mode: u8

protocol_a_fee: u64

protocol_b_fee: u64

partner_a_fee: u64

partner_b_fee: u64

sqrt_min_price: u128

sqrt_max_price: u128

version: u8

Implementations

impl MeteoraDammV2Pool

pub fn calculate_base_fee_numerator( &self, central_context: &Arc<CentralContext>, ) -> u64

Calculate the base fee numerator for DAMMv2 pools with fee scheduling

Supports multiple fee modes:

• Linear decay: Fee decreases linearly over periods
• Exponential decay: Fee decreases exponentially over periods
• Rate limiter: Not yet implemented, returns cliff fee

The calculation is based on the activation point and elapsed time/slots since activation.

impl MeteoraDammV2Pool

pub fn calculate_dynamic_fee_numerator(&self) -> u64

Calculate the dynamic fee numerator based on volatility

The dynamic fee increases with volatility according to the formula: ((volatility_accumulator * bin_step)^2 * variable_fee_control + 99_999_999_999) / 100_000_000_000

Returns 0 if dynamic fees are not initialized or variable fee control is disabled.

impl MeteoraDammV2Pool

pub fn from_account_info(pubkey: Pubkey, account_buffer: &[u8]) -> Self

Create a Meteora DAMMv2 pool from on-chain account data

Parses the account buffer using the Meteora DAMMv2 pool IDL structure. DAMMv2 pools support dynamic fees based on volatility and time-based schedules.

Trait Implementations

impl Debug for MeteoraDammV2Pool

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PoolTrait for MeteoraDammV2Pool

fn directional_fees( &self, direction: SwapDirection, central_context: &Arc<CentralContext>, ) -> (f64, f64)

Returns the directional fees for a given swap direction as fractions. Meteora DAMMV2 charges fees on ONLY ONE token at a time:

• In BothToken mode (collect_fee_mode=0): fees are charged on the OUTPUT token. It says this in the program source code
• In OnlyB mode (collect_fee_mode=1): fees are always charged on token B (input or output)

fn token_a_amount_units(&self) -> u64

Get the actual amount of token A in the pool, in token units. This is calculated dynamically because some protocols (like Meteora) derive real token balances from LP token balances rather than storing them directly in the pool account, and other protocols require excluding collected fees from raw reserves.

fn token_b_amount_units(&self) -> u64

Get the actual amount of token B in the pool, in token units. See token_a_amount_units for details on why this is calculated dynamically.

fn pool_address(&self) -> &Pubkey

Get the pool’s on-chain address

fn token_a_address(&self) -> &Pubkey

Get the address of token A

fn token_b_address(&self) -> &Pubkey

Get the address of token B

fn token_a_vault_address(&self) -> &Pubkey

Get the vault address for token A

fn token_b_vault_address(&self) -> &Pubkey

Get the vault address for token B

fn pool_type(&self) -> &Pools

Get the pool type enum variant

fn total_swap_fee_lp(&self, central_context: &Arc<CentralContext>) -> u64

Get the total swap fee in lamports (10^9 lamports = 1 SOL)

fn as_any(&self) -> &dyn Any

Get a reference to the pool as Any for type downcasting

fn as_any_mut(&mut self) -> &mut dyn Any

Get a mutable reference to the pool as Any for type downcasting

fn price_a_over_b_lp(&self) -> u128

Calculate the price of token A in terms of token B. Fx ticker equivalent: B/A. Returns how many units of token A are needed to buy 1 unit of token B, in lamports. For AMMs, typically calculated as: (A reserves * LAMPORTS_PER_SOL) / B reserves

fn price_b_over_a_lp(&self) -> u128

Calculate the price of token B in terms of token A. Fx ticker equivalent: A/B. Returns how many units of token A are needed to buy 1 unit of token B, in lamports. For AMMs, typically calculated as: (B reserves * LAMPORTS_PER_SOL) / A reserves. Inverse of price_a_over_b_lp.

fn fetch_market_state_from_rpc(&mut self, central_context: &Arc<CentralContext>)

Fetch and update pool state from JSON RPC and immediately overrides the in-memory pool state. Should not be used in production in favor of using gRPC streams.