Struct RocketpoolState 

pub struct RocketpoolState {

    pub reth_supply: U256,
    pub total_eth: U256,
    pub deposit_contract_balance: U256,
    pub reth_contract_liquidity: U256,
    pub deposit_fee: U256,
    pub deposits_enabled: bool,
    pub min_deposit_amount: U256,
    pub max_deposit_pool_size: U256,
    pub deposit_assigning_enabled: bool,
    pub deposit_assign_maximum: U256,
    pub deposit_assign_socialised_maximum: U256,
    pub queue_variable_start: U256,
    pub queue_variable_end: U256,
}

Fields

reth_supply: U256

total_eth: U256

deposit_contract_balance: U256

ETH available in the deposit pool contract

reth_contract_liquidity: U256

ETH available in the rETH contract

deposit_fee: U256

Deposit fee as %, scaled by DEPOSIT_FEE_BASE, such as 5000000000000000 represents 0.5% fee.

deposits_enabled: bool

min_deposit_amount: U256

max_deposit_pool_size: U256

deposit_assigning_enabled: bool

Whether assigning deposits is enabled (allows using minipool queue capacity)

deposit_assign_maximum: U256

Maximum number of minipool assignments per deposit

deposit_assign_socialised_maximum: U256

The base number of minipools to try to assign per deposit

queue_variable_start: U256

Minipool queue indices for variable deposits

queue_variable_end: U256

Implementations

impl RocketpoolState

pub fn new( reth_supply: U256, total_eth: U256, deposit_contract_balance: U256, reth_contract_liquidity: U256, deposit_fee: U256, deposits_enabled: bool, min_deposit_amount: U256, max_deposit_pool_size: U256, deposit_assigning_enabled: bool, deposit_assign_maximum: U256, deposit_assign_socialised_maximum: U256, queue_variable_start: U256, queue_variable_end: U256, ) -> Self

Trait Implementations

impl Clone for RocketpoolState

fn clone(&self) -> RocketpoolState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RocketpoolState

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

Formats the value using the given formatter.

impl PartialEq for RocketpoolState

fn eq(&self, other: &RocketpoolState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ProtocolSim for RocketpoolState

fn fee(&self) -> f64

Returns the fee of the protocol as ratio

fn spot_price( &self, _base: &Token, quote: &Token, ) -> Result<f64, SimulationError>

Returns the protocol’s current spot price of two tokens

fn get_amount_out( &self, amount_in: BigUint, token_in: &Token, _token_out: &Token, ) -> Result<GetAmountOutResult, SimulationError>

Returns the amount out given an amount in and input/output tokens.

fn get_limits( &self, sell_token: Bytes, _buy_token: Bytes, ) -> Result<(BigUint, BigUint), SimulationError>

Computes the maximum amount that can be traded between two tokens.

fn delta_transition( &mut self, delta: ProtocolStateDelta, _tokens: &HashMap<Bytes, Token>, _balances: &Balances, ) -> Result<(), TransitionError<String>>

Decodes and applies a protocol state delta to the state

fn clone_box(&self) -> Box<dyn ProtocolSim>

Clones the protocol state as a trait object. This allows the state to be cloned when it is being used as a Box<dyn ProtocolSim>.

fn as_any(&self) -> &dyn Any

Allows downcasting of the trait object to its underlying type.

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

Allows downcasting of the trait object to its mutable underlying type.

fn eq(&self, other: &dyn ProtocolSim) -> bool

Compares two protocol states for equality. This method must be implemented to define how two protocol states are considered equal (used for tests).

fn query_pool_swap( &self, params: &QueryPoolSwapParams, ) -> Result<PoolSwap, SimulationError>

Calculates the swap volume required to achieve the provided goal when trading against this pool.

fn as_indicatively_priced( &self, ) -> Result<&(dyn IndicativelyPriced + 'static), SimulationError>

Cast as IndicativelyPriced. This is necessary for RFQ protocols

impl TryFromWithBlock<ComponentWithState, BlockHeader> for RocketpoolState

async fn try_from_with_header( snapshot: ComponentWithState, _block: BlockHeader, _account_balances: &HashMap<Bytes, HashMap<Bytes, Bytes>>, _all_tokens: &HashMap<Bytes, Token>, _decoder_context: &DecoderContext, ) -> Result<Self, Self::Error>

Decodes a ComponentWithState into a RocketpoolState. Errors with a InvalidSnapshotError if any required attribute is missing.

type Error = InvalidSnapshotError

impl StructuralPartialEq for RocketpoolState