feat: v1 quote interface proposal (#837)

kayibal · web-flow · commit a448aae4151b · 2026-02-20T15:53:17.000-06:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/tycho-common/Cargo.toml b/tycho-common/Cargo.toml
@@ -35,7 +35,8 @@ tiny-keccak = { version = "2.0.2", features = ["keccak"] }
 bytes = "1.5.0"
 mockall = { workspace = true, optional = true }
 num-bigint = "0.4"
-deepsize.workspace = true # perf: make optional, as used only by the indexer for memory profiling
+deepsize.workspace = true# perf: make optional, as used only by the indexer for memory profiling
+itertools = "0.10.5"
 
 [dev-dependencies]
 serde_json.workspace = true
diff --git a/tycho-common/src/dto.rs b/tycho-common/src/dto.rs
@@ -687,14 +687,21 @@ impl DeepSizeOf for ProtocolComponent {
     }
 }
 
-impl From<models::protocol::ProtocolComponent> for ProtocolComponent {
-    fn from(value: models::protocol::ProtocolComponent) -> Self {
+impl<T> From<models::protocol::ProtocolComponent<T>> for ProtocolComponent
+where
+    T: Into<Address> + Clone,
+{
+    fn from(value: models::protocol::ProtocolComponent<T>) -> Self {
         Self {
             id: value.id,
             protocol_system: value.protocol_system,
             protocol_type_name: value.protocol_type_name,
             chain: value.chain.into(),
-            tokens: value.tokens,
+            tokens: value
+                .tokens
+                .into_iter()
+                .map(|t| t.into())
+                .collect(),
             contract_ids: value.contract_addresses,
             static_attributes: value.static_attributes,
             change: value.change.into(),
diff --git a/tycho-common/src/models/mod.rs b/tycho-common/src/models/mod.rs
@@ -280,7 +280,7 @@ impl ProtocolType {
     }
 }
 
-#[derive(Debug, PartialEq, Default, Copy, Clone, Deserialize, Serialize, DeepSizeOf)]
+#[derive(Debug, PartialEq, Eq, Default, Copy, Clone, Deserialize, Serialize, DeepSizeOf)]
 pub enum ChangeType {
     #[default]
     Update,
diff --git a/tycho-common/src/models/protocol.rs b/tycho-common/src/models/protocol.rs
@@ -1,4 +1,7 @@
-use std::collections::{HashMap, HashSet};
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
 
 use chrono::NaiveDateTime;
 use deepsize::{Context, DeepSizeOf};
@@ -7,8 +10,8 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     models::{
-        Address, AttrStoreKey, Balance, Chain, ChangeType, ComponentId, MergeError, StoreVal,
-        TxHash,
+        token::Token, Address, AttrStoreKey, Balance, Chain, ChangeType, ComponentId, MergeError,
+        StoreVal, TxHash,
     },
     Bytes,
 };
@@ -24,28 +27,31 @@ use crate::{
 ///
 /// Every values of a `ProtocolComponent` must be static, they can't ever be changed after creation.
 /// The dynamic values associated to a component must be given using `ProtocolComponentState`.
-#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq)]
-pub struct ProtocolComponent {
+#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ProtocolComponent<Token: Into<Address> + Clone = Address> {
     pub id: ComponentId,
     pub protocol_system: String,
     pub protocol_type_name: String,
     pub chain: Chain,
-    pub tokens: Vec<Address>,
+    pub tokens: Vec<Token>,
     pub contract_addresses: Vec<Address>,
     pub static_attributes: HashMap<AttrStoreKey, StoreVal>,
     pub change: ChangeType,
     pub creation_tx: TxHash,
     pub created_at: NaiveDateTime,
 }
 
-impl ProtocolComponent {
+impl<T> ProtocolComponent<T>
+where
+    T: Into<Address> + Clone,
+{
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         id: &str,
         protocol_system: &str,
         protocol_type_name: &str,
         chain: Chain,
-        tokens: Vec<Address>,
+        tokens: Vec<T>,
         contract_addresses: Vec<Address>,
         static_attributes: HashMap<AttrStoreKey, StoreVal>,
         change: ChangeType,
@@ -67,6 +73,15 @@ impl ProtocolComponent {
     }
 }
 
+impl ProtocolComponent<Arc<Token>> {
+    pub fn get_token(&self, address: &Address) -> Option<Arc<Token>> {
+        self.tokens
+            .iter()
+            .find(|t| &t.address == address)
+            .map(Arc::clone)
+    }
+}
+
 impl DeepSizeOf for ProtocolComponent {
     fn deep_size_of_children(&self, ctx: &mut Context) -> usize {
         self.id.deep_size_of_children(ctx) +
diff --git a/tycho-common/src/models/token.rs b/tycho-common/src/models/token.rs
@@ -1,6 +1,7 @@
 use std::{
     collections::HashMap,
     hash::{Hash, Hasher},
+    sync::Arc,
 };
 
 use deepsize::DeepSizeOf;
@@ -97,6 +98,12 @@ impl Hash for Token {
     }
 }
 
+impl From<Arc<Token>> for Address {
+    fn from(val: Arc<Token>) -> Self {
+        val.address.clone()
+    }
+}
+
 impl TryFrom<ResponseToken> for Token {
     type Error = ();
 
diff --git a/tycho-common/src/simulation/errors.rs b/tycho-common/src/simulation/errors.rs
@@ -23,15 +23,14 @@ pub enum SimulationError {
 }
 
 #[derive(Debug)]
-pub enum TransitionError<T> {
-    OutOfOrder { state: T, event: T },
+pub enum TransitionError {
     MissingAttribute(String),
     DecodeError(String),
     InvalidEventType(),
     SimulationError(SimulationError),
 }
 
-impl<T> From<SimulationError> for TransitionError<T> {
+impl From<SimulationError> for TransitionError {
     fn from(error: SimulationError) -> Self {
         TransitionError::SimulationError(error)
     }
diff --git a/tycho-common/src/simulation/mod.rs b/tycho-common/src/simulation/mod.rs
@@ -1,3 +1,4 @@
 pub mod errors;
 pub mod indicatively_priced;
 pub mod protocol_sim;
+pub mod swap;
diff --git a/tycho-common/src/simulation/protocol_sim.rs b/tycho-common/src/simulation/protocol_sim.rs
@@ -8,11 +8,14 @@ use crate::{
     simulation::{
         errors::{SimulationError, TransitionError},
         indicatively_priced::IndicativelyPriced,
+        swap::{
+            self, LimitsParams, MarginalPriceParams, QuoteParams, SwapQuoter, TransitionParams,
+        },
     },
     Bytes,
 };
 
-#[derive(Default)]
+#[derive(Default, Debug, Clone)]
 pub struct Balances {
     pub component_balances: HashMap<String, HashMap<Bytes, Bytes>>,
     pub account_balances: HashMap<Bytes, HashMap<Bytes, Bytes>>,
@@ -347,7 +350,7 @@ pub trait ProtocolSim: fmt::Debug + Send + Sync + 'static {
         delta: ProtocolStateDelta,
         tokens: &HashMap<Bytes, Token>,
         balances: &Balances,
-    ) -> Result<(), TransitionError<String>>;
+    ) -> Result<(), TransitionError>;
 
     /// Calculates the swap volume required to achieve the provided goal when trading against this
     /// pool.
@@ -403,6 +406,149 @@ impl Clone for Box<dyn ProtocolSim> {
     }
 }
 
+impl<T> ProtocolSim for T
+where
+    T: SwapQuoter + Clone + Send + Sync + Eq + 'static,
+{
+    fn fee(&self) -> f64 {
+        self.quotable_pairs()
+            .iter()
+            .map(|(t0, t1)| {
+                let amount = BigUint::from(10u32).pow(t0.decimals);
+                if let Ok(params) = QuoteParams::fixed_in(&t0.address, &t1.address, amount) {
+                    self.fee(params)
+                        .map(|f| f.fee())
+                        .unwrap_or(f64::MAX)
+                } else {
+                    f64::MAX
+                }
+            })
+            .reduce(f64::min)
+            .unwrap_or(f64::MAX)
+    }
+
+    fn spot_price(&self, base: &Token, quote: &Token) -> Result<f64, SimulationError> {
+        self.marginal_price(MarginalPriceParams::new(&base.address, &quote.address))
+            .map(|r| r.price())
+    }
+
+    fn get_amount_out(
+        &self,
+        amount_in: BigUint,
+        token_in: &Token,
+        token_out: &Token,
+    ) -> Result<GetAmountOutResult, SimulationError> {
+        #[allow(deprecated)]
+        self.quote(
+            QuoteParams::fixed_in(&token_in.address, &token_out.address, amount_in)?
+                .with_new_state(),
+        )
+        .map(|r| {
+            GetAmountOutResult::new(
+                r.amount_out().clone(),
+                r.gas().clone(),
+                r.new_state()
+                    .expect("quote includes new state")
+                    .to_protocol_sim(),
+            )
+        })
+    }
+
+    fn get_limits(
+        &self,
+        sell_token: Bytes,
+        buy_token: Bytes,
+    ) -> Result<(BigUint, BigUint), SimulationError> {
+        self.swap_limits(LimitsParams::new(&sell_token, &buy_token))
+            .map(|r| (r.range_in().upper().clone(), r.range_out().upper().clone()))
+    }
+
+    fn delta_transition(
+        &mut self,
+        delta: ProtocolStateDelta,
+        tokens: &HashMap<Bytes, Token>,
+        balances: &Balances,
+    ) -> Result<(), TransitionError> {
+        self.delta_transition(TransitionParams::new(delta, tokens, balances))
+            .map(|_| ())
+    }
+
+    fn query_pool_swap(&self, params: &QueryPoolSwapParams) -> Result<PoolSwap, SimulationError> {
+        let constraint = match params.swap_constraint.clone() {
+            SwapConstraint::TradeLimitPrice { limit, tolerance, min_amount_in, max_amount_in } => {
+                swap::SwapConstraint::TradeLimitPrice {
+                    limit,
+                    tolerance,
+                    min_amount_in,
+                    max_amount_in,
+                }
+            }
+            SwapConstraint::PoolTargetPrice { target, tolerance, min_amount_in, max_amount_in } => {
+                swap::SwapConstraint::PoolTargetPrice {
+                    target,
+                    tolerance,
+                    min_amount_in,
+                    max_amount_in,
+                }
+            }
+        };
+        #[allow(deprecated)]
+        self.query_swap(swap::QuerySwapParams::new(
+            &params.token_in.address,
+            &params.token_out.address,
+            constraint,
+        ))
+        .map(|r| {
+            PoolSwap::new(
+                r.amount_in().clone(),
+                r.amount_out().clone(),
+                r.new_state().unwrap().to_protocol_sim(),
+                r.price_points().as_ref().map(|points| {
+                    points
+                        .iter()
+                        .map(|p| {
+                            PricePoint::new(
+                                p.amount_in().clone(),
+                                p.amount_out().clone(),
+                                p.price(),
+                            )
+                        })
+                        .collect()
+                }),
+            )
+        })
+    }
+
+    fn clone_box(&self) -> Box<dyn ProtocolSim> {
+        #[allow(deprecated)]
+        self.to_protocol_sim()
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    fn eq(&self, other: &dyn ProtocolSim) -> bool {
+        if let Some(other) = other.as_any().downcast_ref::<T>() {
+            self == other
+        } else {
+            false
+        }
+    }
+
+    fn typetag_name(&self) -> &'static str {
+        self.typetag_name()
+    }
+
+    fn typetag_deserialize(&self) {
+        self.typetag_deserialize()
+    }
+}
+
 #[cfg(test)]
 mod tests {
 
@@ -466,7 +612,7 @@ mod tests {
                 _delta: ProtocolStateDelta,
                 _tokens: &HashMap<Bytes, Token>,
                 _balances: &Balances,
-            ) -> Result<(), TransitionError<String>> {
+            ) -> Result<(), TransitionError> {
                 todo!()
             }
         }
diff --git a/tycho-common/src/simulation/swap.rs b/tycho-common/src/simulation/swap.rs

Original file line number	Diff line number	Diff line change
`@@ -280,7 +280,7 @@ impl ProtocolType {`
`280`	`280`	`}`
`281`	`281`	`}`
`282`	`282`
`283`		`-#[derive(Debug, PartialEq, Default, Copy, Clone, Deserialize, Serialize, DeepSizeOf)]`
	`283`	`+#[derive(Debug, PartialEq, Eq, Default, Copy, Clone, Deserialize, Serialize, DeepSizeOf)]`
`284`	`284`	`pub enum ChangeType {`
`285`	`285`	`#[default]`
`286`	`286`	`Update,`
Original file line number	Diff line number	Diff line change
`@@ -23,15 +23,14 @@ pub enum SimulationError {`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`#[derive(Debug)]`
`26`		`-pub enum TransitionError<T> {`
`27`		`- OutOfOrder { state: T, event: T },`
	`26`	`+pub enum TransitionError {`
`28`	`27`	`MissingAttribute(String),`
`29`	`28`	`DecodeError(String),`
`30`	`29`	`InvalidEventType(),`
`31`	`30`	`SimulationError(SimulationError),`
`32`	`31`	`}`
`33`	`32`
`34`		`-impl<T> From<SimulationError> for TransitionError<T> {`
	`33`	`+impl From<SimulationError> for TransitionError {`
`35`	`34`	`fn from(error: SimulationError) -> Self {`
`36`	`35`	`TransitionError::SimulationError(error)`
`37`	`36`	`}`