Struct RaydiumAmmV4Pool

pub struct RaydiumAmmV4Pool {
    pub info: Pool,
    pub token_a_vault_amount: u64,
    pub token_b_vault_amount: u64,
    pub swap_fee_numerator: u64,
    pub swap_fee_denominator: u64,
}

Struct to hold data and PoolTrait implementation for Raydium AmmV4 pools. The only things you actually need to trade on a Raydium AmmV4 at least are these things: the liquidity pool program address, baseVault, quoteVault. The rest of the fields can be constant blasted as random values and the program will not care because Serum and Openbook are no longer in use for these AMMs.

Fields

info: Pool

token_a_vault_amount: u64

token_b_vault_amount: u64

swap_fee_numerator: u64

swap_fee_denominator: u64

Implementations

impl RaydiumAmmV4Pool

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

Create a Raydium AMMv4 pool from on-chain account data

Parses the account buffer using the Raydium AMMv4 pool IDL structure.

Trait Implementations

impl Debug for RaydiumAmmV4Pool

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

Formats the value using the given formatter.

impl PoolTrait for RaydiumAmmV4Pool

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, _: &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.

fn directional_fees( &self, swap_direction: SwapDirection, _: &Arc<CentralContext>, ) -> (f64, f64)

Get directional swap fees as fractions for a given swap direction