Struct PumpswapPool

pub struct PumpswapPool {
    pub info: Pool,
    pub pool_creator: Pubkey,
    pub coin_creator: Pubkey,
    pub fee_vault: Pubkey,
    pub fee_vault_token_account: Pubkey,
    pub token_a_vault_amount: u64,
    pub token_b_vault_amount: u64,
    pub coin_creator_vault_authority: Pubkey,
    pub coin_creator_vault_authority_token_account: Pubkey,
}

Struct to hold data and PoolTrait implementation for Pumpswap pools.

Fields

info: Pool

pool_creator: Pubkey

coin_creator: Pubkey

fee_vault: Pubkey

fee_vault_token_account: Pubkey

token_a_vault_amount: u64

token_b_vault_amount: u64

coin_creator_vault_authority: Pubkey

coin_creator_vault_authority_token_account: Pubkey

Implementations

impl PumpswapPool

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

Create a Pumpswap pool from on-chain account data

Parses the account buffer and derives associated fee vault and creator vault addresses.

impl PumpswapPool

pub fn pump_pool_authority_pda( base_mint: &Pubkey, ) -> Result<Pubkey, PubkeyError>

pub fn is_canonical_pool(&self) -> bool

pub fn calculate_market_cap_lamports(&self) -> Option<u64>

pub fn get_canonical_fee_breakdown(&self) -> (u64, u64, u64)

pub fn get_fee_breakdown(&self) -> (u64, u64, u64)

Trait Implementations

impl Debug for PumpswapPool

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

Formats the value using the given formatter.

impl PoolTrait for PumpswapPool

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, _: SwapDirection, central_context: &Arc<CentralContext>, ) -> (f64, f64)

Get directional swap fees as fractions for a given swap direction