Struct LBPool 

pub struct LBPool {

    pub address: Address,
    pub token_x: Address,
    pub token_y: Address,
    pub bin_step: u16,
    pub active_id: u32,
    pub bins: BTreeMap<u32, (u128, u128)>,
    pub base_factor: u16,
    pub filter_period: u16,
    pub decay_period: u16,
    pub reduction_factor: u16,
    pub variable_fee_control: u32,
    pub protocol_share: u16,
    pub max_volatility_accumulator: u32,
    pub volatility_accumulator: u32,
    pub volatility_reference: u32,
    pub id_reference: u32,
    pub time_of_last_update: u64,
    pub last_updated: u64,
    pub created_at: u64,
}

TraderJoe Liquidity Book pool.

Bin-based AMM where each bin uses constant-sum liquidity: L = price * x + y. Swaps iterate through bins from active_id, consuming input per bin.

Fields

address: Address

token_x: Address

token_y: Address

bin_step: u16

active_id: u32

bins: BTreeMap<u32, (u128, u128)>

Bin ID -> (reserve_x, reserve_y). Only non-empty bins are stored.

base_factor: u16

filter_period: u16

decay_period: u16

reduction_factor: u16

variable_fee_control: u32

protocol_share: u16

max_volatility_accumulator: u32

volatility_accumulator: u32

volatility_reference: u32

id_reference: u32

time_of_last_update: u64

last_updated: u64

created_at: u64

Implementations

impl LBPool

pub fn new( address: Address, token_x: Address, token_y: Address, bin_step: u16, active_id: u32, bins: BTreeMap<u32, (u128, u128)>, base_factor: u16, filter_period: u16, decay_period: u16, reduction_factor: u16, variable_fee_control: u32, protocol_share: u16, max_volatility_accumulator: u32, volatility_accumulator: u32, volatility_reference: u32, id_reference: u32, time_of_last_update: u64, ) -> Self

pub fn get_total_fee(&self) -> u128

Current total fee in 1e18 precision.

pub fn fee_f64(&self) -> f64

Fee as an f64 fraction (e.g., 0.003 for 0.3%).

pub fn update_bin(&mut self, id: u32, reserve_x: u128, reserve_y: u128)

Update a bin’s reserves. Removes the bin if both reserves are zero.

pub fn simulate_swap_out( &self, amount_in: u128, swap_for_y: bool, ) -> Result<(u128, u128, u128)>

Simulate getSwapOut: given amount_in of one token, compute output.

Uses current wall-clock time for volatility decay. For exact on-chain comparison at a specific block, use [simulate_swap_out_at].

pub fn simulate_swap_out_at( &self, amount_in: u128, swap_for_y: bool, timestamp: u64, ) -> Result<(u128, u128, u128)>

Simulate getSwapOut with an explicit timestamp for volatility decay.

Exact port of LBPair.getSwapOut(). Returns (amount_in_left, amount_out, fee). The timestamp should be the block timestamp for exact on-chain comparison.

pub fn simulate_swap_in( &self, amount_out: u128, swap_for_y: bool, ) -> Result<(u128, u128, u128)>

Simulate getSwapIn: given desired amount_out, compute required input.

Uses current wall-clock time for volatility decay.

pub fn simulate_swap_in_at( &self, amount_out: u128, swap_for_y: bool, timestamp: u64, ) -> Result<(u128, u128, u128)>

Simulate getSwapIn with an explicit timestamp for volatility decay.

Exact port of LBPair.getSwapIn(). Returns (amount_in, amount_out_left, fee).

Trait Implementations

impl Clone for LBPool

fn clone(&self) -> LBPool

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LBPool

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LBPool

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for LBPool

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

Formats the value using the given formatter.

impl EventApplicable for LBPool

fn apply_log(&mut self, event: &Log) -> Result<()>

Apply an event to update the pool state

impl PoolInterface for LBPool

fn calculate_output(&self, token_in: &Address, amount_in: U256) -> Result<U256>

Calculate output amount for a swap given an input amount and token

fn calculate_input(&self, token_out: &Address, amount_out: U256) -> Result<U256>

Calculate input amount for a swap given an output amount and token

fn apply_swap( &mut self, _token_in: &Address, _amount_in: U256, _amount_out: U256, ) -> Result<()>

Apply a swap to the pool state

fn address(&self) -> Address

Get the pool address

fn tokens(&self) -> (Address, Address)

Get the tokens in the pool

fn fee(&self) -> f64

Get the pool fee as a fraction (e.g., 0.003 for 0.3%)

fn fee_raw(&self) -> u64

fn id(&self) -> String

Get a unique identifier for the pool

fn contains_token(&self, token: &Address) -> bool

Check if the pool contains a token

fn clone_box(&self) -> Box<dyn PoolInterface + Send + Sync>

Clone the pool interface to a box

fn log_summary(&self) -> String

Log summary of the pool

fn as_any(&self) -> &dyn Any

Helper method for downcasting

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

fn token0(&self) -> Address

Get token0 of the pool

fn token1(&self) -> Address

Get token1 of the pool

impl PoolTypeTrait for LBPool

fn pool_type(&self) -> PoolType

impl Serialize for LBPool

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TopicList for LBPool

fn topics() -> Vec<Topic>

fn profitable_topics() -> Vec<Topic>