Struct CurveState 

pub struct CurveState { /* private fields */ }

A single Curve pool quoted via curve_math.

tokens and decimals are ordered to match the pool’s coin indices, so a token address maps directly to a curve_math coin index. State (pool) is rebuilt from the VM on every delta_transition.

Multi-hop limitation: the state returned by ProtocolSim::get_amount_out updates coin balances only, holding D and price_scale fixed. This is exact for StableSwap (which recomputes D from balances on every quote), but a route that re-quotes the same CryptoSwap pool sees an approximation on the second hop, because CryptoSwap caches D and would update it (via tweak_price) after an on-chain exchange.

Trait Implementations

impl Clone for CurveState

fn clone(&self) -> CurveState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CurveState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CurveState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CurveState

fn eq(&self, other: &CurveState) -> 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 CurveState

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 buy price for base in units of quote.

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>

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 Serialize for CurveState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CurveState

impl TryFromWithBlock<ComponentWithState, BlockHeader> for CurveState

async fn try_from_with_header( value: ComponentWithState, _block: BlockHeader, _account_balances: &HashMap<Bytes, HashMap<Bytes, Bytes>>, all_tokens: &HashMap<Bytes, Token>, decoder_context: &DecoderContext, ) -> Result<Self, Self::Error>

Decodes a vm:curve snapshot into a CurveState.

Coin order is taken from the coins static attribute (the pool’s on-chain coin order), not component.tokens (which Tycho sorts by address) — the two differ in general, and the VM getters (balances(i), price_scale(i), …) are indexed in on-chain order. Decimals and the swap-token→index mapping therefore also follow the coins order.

type Error = InvalidSnapshotError