Struct EVMPoolState 

pub struct EVMPoolState<D: EngineDatabaseInterface + Clone + Debug>
where
    <D as DatabaseRef>::Error: Debug,
    <D as EngineDatabaseInterface>::Error: Debug,
{
    pub tokens: Vec<Bytes>,
    /* private fields */
}

Fields

tokens: Vec<Bytes>

The pool’s token’s addresses

Implementations

impl<D> EVMPoolState<D>

where D: EngineDatabaseInterface + Clone + Debug + 'static, <D as DatabaseRef>::Error: Debug, <D as EngineDatabaseInterface>::Error: Debug,

pub fn new( id: String, tokens: Vec<Bytes>, component_balances: HashMap<Address, U256>, balance_owner: Option<Address>, contract_balances: HashMap<Address, HashMap<Address, U256>>, spot_prices: HashMap<(Address, Address), f64>, capabilities: HashSet<Capability>, block_lasting_overwrites: HashMap<Address, HashMap<SlotId, U256>>, involved_contracts: HashSet<Address>, manual_updates: bool, adapter_contract: TychoSimulationContract<D>, disable_overwrite_tokens: HashSet<Address>, ) -> Self

Creates a new instance of EVMPoolState with the given attributes, with the ability to simulate a protocol-agnostic transaction.

See struct definition of EVMPoolState for attribute explanations.

pub fn set_spot_prices( &mut self, tokens: &HashMap<Bytes, Token>, ) -> Result<(), SimulationError>

Sets the spot prices for a pool for all possible pairs of the given tokens.

Arguments

• tokens - A hashmap of Token instances representing the tokens to calculate spot prices for.

Returns

• Result<(), SimulationError> - Returns Ok(()) if the spot prices are successfully set, or a SimulationError if an error occurs during the calculation or processing.

Behavior

This function performs the following steps:

1. Ensures the pool has the required capability to perform price calculations.
2. Iterates over all permutations of token pairs (sell token and buy token). For each pair:
   • Retrieves all possible overwrites, considering the maximum balance limit.
   • Calculates the sell amount limit, considering the overwrites.
   • Invokes the adapter contract’s price function to retrieve the calculated price for the token pair, considering the sell amount limit.
   • Processes the price based on whether the ScaledPrice capability is present:
     • If ScaledPrice is present, uses the price directly from the adapter contract.
     • If ScaledPrice is absent, scales the price by adjusting for token decimals.
   • Stores the calculated price in the spot_prices map with the token addresses as the key.
3. Returns Ok(()) upon successful completion or a SimulationError upon failure.

Usage

Spot prices need to be set before attempting to retrieve prices using spot_price.

Tip: Setting spot prices on the pool every time the pool actually changes will result in faster price fetching than if prices are only set immediately before attempting to retrieve prices.

pub fn get_balances(&self) -> &HashMap<Address, U256>

Get the component balances for validation purposes

Trait Implementations

impl<D: Clone + EngineDatabaseInterface + Clone + Debug> Clone for EVMPoolState<D>

where <D as DatabaseRef>::Error: Debug, <D as EngineDatabaseInterface>::Error: Debug,

fn clone(&self) -> EVMPoolState<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D> Debug for EVMPoolState<D>

where D: EngineDatabaseInterface + Clone + Debug, <D as DatabaseRef>::Error: Debug, <D as EngineDatabaseInterface>::Error: Debug,

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

Formats the value using the given formatter.

impl<D> ProtocolSim for EVMPoolState<D>

where D: EngineDatabaseInterface + Clone + Debug + 'static, <D as DatabaseRef>::Error: Debug, <D as EngineDatabaseInterface>::Error: Debug,

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 EVMPoolState<PreCachedDB>

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, block BlockHeader and HashMap of all available tokens into an EVMPoolState.

Errors with a InvalidSnapshotError.

type Error = InvalidSnapshotError