Price competition bang for buck

crates/autopilot/src/run.rs

@@ -413,13 +413,6 @@ pub async fn run(args: Arguments) {
     )
     .expect("failed to initialize price estimator factory");
 
-    let price_estimator = price_estimator_factory
-        .price_estimator(&PriceEstimatorSource::for_args(
-            args.order_quoting.price_estimators.as_slice(),
-            &args.order_quoting.price_estimation_drivers,
-            &args.order_quoting.price_estimation_legacy_solvers,
-        ))
-        .unwrap();
     let native_price_estimator = price_estimator_factory
         .native_price_estimator(
             args.native_price_estimators.as_slice(),
@@ -431,6 +424,16 @@ pub async fn run(args: Arguments) {
             args.native_price_estimation_results_required,
         )
         .unwrap();
+    let price_estimator = price_estimator_factory
+        .price_estimator(
+            &PriceEstimatorSource::for_args(
+                args.order_quoting.price_estimators.as_slice(),
+                &args.order_quoting.price_estimation_drivers,
+                &args.order_quoting.price_estimation_legacy_solvers,
+            ),
+            native_price_estimator.clone(),
+        )
+        .unwrap();
 
     let skip_event_sync_start = if args.skip_event_sync {
         block_number_to_block_number_hash(&web3, BlockNumber::Latest).await

crates/orderbook/src/run.rs

@@ -393,15 +393,9 @@ pub async fn run(args: Arguments) {
     )
     .expect("failed to initialize price estimator factory");
 
-    let price_estimator = price_estimator_factory
-        .price_estimator(&PriceEstimatorSource::for_args(
-            args.order_quoting.price_estimators.as_slice(),
-            &args.order_quoting.price_estimation_drivers,
-            &args.order_quoting.price_estimation_legacy_solvers,
-        ))
-        .unwrap();
-    let fast_price_estimator = price_estimator_factory
-        .fast_price_estimator(
+    let native_price_estimator = price_estimator_factory
+        .native_price_estimator(
+            args.native_price_estimators.as_slice(),
             &PriceEstimatorSource::for_args(
                 args.order_quoting.price_estimators.as_slice(),
                 &args.order_quoting.price_estimation_drivers,
@@ -410,15 +404,25 @@ pub async fn run(args: Arguments) {
             args.fast_price_estimation_results_required,
         )
         .unwrap();
-    let native_price_estimator = price_estimator_factory
-        .native_price_estimator(
-            args.native_price_estimators.as_slice(),
+    let price_estimator = price_estimator_factory
+        .price_estimator(
+            &PriceEstimatorSource::for_args(
+                args.order_quoting.price_estimators.as_slice(),
+                &args.order_quoting.price_estimation_drivers,
+                &args.order_quoting.price_estimation_legacy_solvers,
+            ),
+            native_price_estimator.clone(),
+        )
+        .unwrap();
+    let fast_price_estimator = price_estimator_factory
+        .fast_price_estimator(
             &PriceEstimatorSource::for_args(
                 args.order_quoting.price_estimators.as_slice(),
                 &args.order_quoting.price_estimation_drivers,
                 &args.order_quoting.price_estimation_legacy_solvers,
             ),
             args.fast_price_estimation_results_required,
+            native_price_estimator.clone(),
         )
         .unwrap();
 

crates/shared/src/price_estimation.rs

@@ -490,6 +490,17 @@ impl Estimate {
         let (sell_amount, buy_amount) = self.amounts(query);
         buy_amount.to_f64_lossy() / sell_amount.to_f64_lossy()
     }
+
+    /// Computes the actual received value from this estimate that takes `gas`
+    /// into account. If an extremely complex trade route would only result
+    /// in slightly more `out_amount` than a simple trade route the simple
+    /// trade route wourd report a higher `out_amount_in_eth`. This is also
+    /// referred to as "bang-for-buck" and what matters most to traders.
+    pub fn out_amount_in_eth(&self, native_out_token_price: f64) -> U256 {
+        let eth_value = self.out_amount.to_f64_lossy() * native_out_token_price;
+        let eth_value = U256::from_f64_lossy(eth_value);
+        eth_value.saturating_sub(self.gas.into())
+    }
 }
 
 pub type PriceEstimateResult = Result<Estimate, PriceEstimationError>;

crates/shared/src/price_estimation/competition.rs

@@ -50,20 +50,23 @@ type PriceEstimationStage<T> = Vec<(String, T)>;
 /// stage Returns a price estimation early if there is a configurable number of
 /// successful estimates for every query or if all price sources returned an
 /// estimate.
-pub struct RacingCompetitionEstimator<T> {
+pub struct RacingCompetitionEstimator<T, N> {
     inner: Vec<PriceEstimationStage<T>>,
     successful_results_for_early_return: NonZeroUsize,
+    native: N,
 }
 
-impl<T: Send + Sync + 'static> RacingCompetitionEstimator<T> {
+impl<T: Send + Sync + 'static, N: Send + Sync + 'static> RacingCompetitionEstimator<T, N> {
     pub fn new(
         inner: Vec<PriceEstimationStage<T>>,
         successful_results_for_early_return: NonZeroUsize,
+        native: N,
     ) -> Self {
         assert!(!inner.is_empty());
         Self {
             inner,
             successful_results_for_early_return,
+            native,
         }
     }
 
@@ -182,24 +185,37 @@ fn successes<R, E>(results: &[(EstimatorIndex, Result<R, E>)]) -> usize {
     results.iter().filter(|(_, result)| result.is_ok()).count()
 }
 
-impl PriceEstimating for RacingCompetitionEstimator<Arc<dyn PriceEstimating>> {
+impl PriceEstimating
+    for RacingCompetitionEstimator<Arc<dyn PriceEstimating>, Arc<dyn NativePriceEstimating>>
+{
     fn estimate(&self, query: Arc<Query>) -> futures::future::BoxFuture<'_, PriceEstimateResult> {
-        self.estimate_generic(
-            query.clone(),
-            query.kind,
-            |estimator, query| estimator.estimate(query),
-            move |a, b| {
-                if is_second_quote_result_preferred(query.as_ref(), a, b) {
-                    Ordering::Less
-                } else {
-                    Ordering::Greater
-                }
-            },
-        )
+        async {
+            let out_token = match query.kind {
+                OrderKind::Buy => query.sell_token,
+                OrderKind::Sell => query.buy_token,
+            };
+            let native_price = self.native.estimate_native_price(out_token).await?;
+            self.estimate_generic(
+                query.clone(),
+                query.kind,
+                |estimator, query| estimator.estimate(query),
+                move |a, b| {
+                    if is_second_quote_result_preferred(query.as_ref(), a, b, native_price) {
+                        Ordering::Less
+                    } else {
+                        Ordering::Greater
+                    }
+                },
+            )
+            .await
+        }
+        .boxed()
     }
 }
 
-impl NativePriceEstimating for RacingCompetitionEstimator<Arc<dyn NativePriceEstimating>> {
+impl<N: Send + Sync + 'static> NativePriceEstimating
+    for RacingCompetitionEstimator<Arc<dyn NativePriceEstimating>, N>
+{
     fn estimate_native_price(
         &self,
         token: H160,
@@ -221,22 +237,24 @@ impl NativePriceEstimating for RacingCompetitionEstimator<Arc<dyn NativePriceEst
 
 /// Price estimator that pulls estimates from various sources
 /// and competes on the best price.
-pub struct CompetitionEstimator<T> {
-    inner: RacingCompetitionEstimator<T>,
+pub struct CompetitionEstimator<T, N> {
+    inner: RacingCompetitionEstimator<T, N>,
 }
 
-impl<T: Send + Sync + 'static> CompetitionEstimator<T> {
-    pub fn new(inner: Vec<Vec<(String, T)>>) -> Self {
+impl<T: Send + Sync + 'static, N: Send + Sync + 'static> CompetitionEstimator<T, N> {
+    pub fn new(inner: Vec<Vec<(String, T)>>, native: N) -> Self {
         let number_of_estimators =
             NonZeroUsize::new(inner.iter().fold(0, |sum, stage| sum + stage.len()))
                 .expect("Vec of estimators should not be empty.");
         Self {
-            inner: RacingCompetitionEstimator::new(inner, number_of_estimators),
+            inner: RacingCompetitionEstimator::new(inner, number_of_estimators, native),
         }
     }
 }
 
-impl PriceEstimating for CompetitionEstimator<Arc<dyn PriceEstimating>> {
+impl PriceEstimating
+    for CompetitionEstimator<Arc<dyn PriceEstimating>, Arc<dyn NativePriceEstimating>>
+{
     fn estimate(&self, query: Arc<Query>) -> futures::future::BoxFuture<'_, PriceEstimateResult> {
         self.inner.estimate(query)
     }
@@ -246,9 +264,10 @@ fn is_second_quote_result_preferred(
     query: &Query,
     a: &PriceEstimateResult,
     b: &PriceEstimateResult,
+    native_price: f64,
 ) -> bool {
     match (a, b) {
-        (Ok(a), Ok(b)) => is_second_estimate_preferred(query, a, b),
+        (Ok(a), Ok(b)) => is_second_estimate_preferred(query, a, b, native_price),
         (Ok(_), Err(_)) => false,
         (Err(_), Ok(_)) => true,
         (Err(a), Err(b)) => is_second_error_preferred(a, b),
@@ -267,10 +286,16 @@ fn is_second_native_result_preferred(
     }
 }
 
-fn is_second_estimate_preferred(query: &Query, a: &Estimate, b: &Estimate) -> bool {
+fn is_second_estimate_preferred(
+    query: &Query,
+    a: &Estimate,
+    b: &Estimate,
+    native_price: f64,
+) -> bool {
+    let amount_out = |estimate: &Estimate| estimate.out_amount_in_eth(native_price);
     match query.kind {
-        OrderKind::Buy => b.out_amount < a.out_amount,
-        OrderKind::Sell => a.out_amount < b.out_amount,
+        OrderKind::Buy => amount_out(b) < amount_out(a),
+        OrderKind::Sell => amount_out(a) < amount_out(b),
     }
 }
 
@@ -321,7 +346,7 @@ fn metrics() -> &'static Metrics {
 mod tests {
     use {
         super::*,
-        crate::price_estimation::MockPriceEstimating,
+        crate::price_estimation::{native::MockNativePriceEstimating, MockPriceEstimating},
         anyhow::anyhow,
         futures::channel::oneshot::channel,
         model::order::OrderKind,
@@ -331,6 +356,16 @@ mod tests {
         tokio::time::sleep,
     };
 
+    /// Builds native price estimator that returns the same native price for any
+    /// token.
+    fn mock_native_estimator() -> Arc<dyn NativePriceEstimating> {
+        let mut estimator = MockNativePriceEstimating::new();
+        estimator
+            .expect_estimate_native_price()
+            .returning(|_token| async { Ok(1.) }.boxed());
+        Arc::new(estimator)
+    }
+
     #[tokio::test]
     async fn works() {
         let queries = [
@@ -418,11 +453,13 @@ mod tests {
             }),
         ]);
 
-        let priority: CompetitionEstimator<Arc<dyn PriceEstimating>> =
-            CompetitionEstimator::new(vec![vec![
+        let priority: CompetitionEstimator<Arc<dyn PriceEstimating>, _> = CompetitionEstimator::new(
+            vec![vec![
                 ("first".to_owned(), Arc::new(first)),
                 ("second".to_owned(), Arc::new(second)),
-            ]]);
+            ]],
+            mock_native_estimator(),
+        );
 
         let result = priority.estimate(queries[0].clone()).await;
         assert_eq!(result.as_ref().unwrap(), &estimates[0]);
@@ -497,14 +534,15 @@ mod tests {
             .boxed()
         });
 
-        let racing: RacingCompetitionEstimator<Arc<dyn PriceEstimating>> =
+        let racing: RacingCompetitionEstimator<Arc<dyn PriceEstimating>, _> =
             RacingCompetitionEstimator::new(
                 vec![vec![
                     ("first".to_owned(), Arc::new(first)),
                     ("second".to_owned(), Arc::new(second)),
                     ("third".to_owned(), Arc::new(third)),
                 ]],
                 NonZeroUsize::new(1).unwrap(),
+                mock_native_estimator(),
             );
 
         let result = racing.estimate(query).await;
@@ -567,7 +605,7 @@ mod tests {
             .boxed()
         });
 
-        let racing: RacingCompetitionEstimator<Arc<dyn PriceEstimating>> =
+        let racing: RacingCompetitionEstimator<Arc<dyn PriceEstimating>, _> =
             RacingCompetitionEstimator::new(
                 vec![
                     vec![
@@ -580,6 +618,7 @@ mod tests {
                     ],
                 ],
                 NonZeroUsize::new(2).unwrap(),
+                mock_native_estimator(),
             );
 
         let result = racing.estimate(query).await;
@@ -638,16 +677,19 @@ mod tests {
         let mut fourth = MockPriceEstimating::new();
         fourth.expect_estimate().never();
 
-        let racing: RacingCompetitionEstimator<Arc<dyn PriceEstimating>> =
-            RacingCompetitionEstimator {
-                inner: vec![
-                    vec![("first".to_owned(), Arc::new(first))],
-                    vec![("second".to_owned(), Arc::new(second))],
-                    vec![("third".to_owned(), Arc::new(third))],
-                    vec![("fourth".to_owned(), Arc::new(fourth))],
-                ],
-                successful_results_for_early_return: NonZeroUsize::new(2).unwrap(),
-            };
+        let racing: RacingCompetitionEstimator<
+            Arc<dyn PriceEstimating>,
+            Arc<dyn NativePriceEstimating>,
+        > = RacingCompetitionEstimator {
+            inner: vec![
+                vec![("first".to_owned(), Arc::new(first))],
+                vec![("second".to_owned(), Arc::new(second))],
+                vec![("third".to_owned(), Arc::new(third))],
+                vec![("fourth".to_owned(), Arc::new(fourth))],
+            ],
+            successful_results_for_early_return: NonZeroUsize::new(2).unwrap(),
+            native: mock_native_estimator(),
+        };
 
         racing.estimate(query).await.unwrap();
     }

crates/shared/src/price_estimation/factory.rs

@@ -336,22 +336,25 @@ impl<'a> PriceEstimatorFactory<'a> {
     pub fn price_estimator(
         &mut self,
         sources: &[PriceEstimatorSource],
+        native: Arc<dyn NativePriceEstimating>,
     ) -> Result<Arc<dyn PriceEstimating>> {
         let estimators = self.get_estimators(sources, |entry| &entry.optimal)?;
-        let competition_estimator = CompetitionEstimator::new(vec![estimators]);
+        let competition_estimator = CompetitionEstimator::new(vec![estimators], native);
         Ok(Arc::new(self.sanitized(Arc::new(competition_estimator))))
     }
 
     pub fn fast_price_estimator(
         &mut self,
         sources: &[PriceEstimatorSource],
         fast_price_estimation_results_required: NonZeroUsize,
+        native: Arc<dyn NativePriceEstimating>,
     ) -> Result<Arc<dyn PriceEstimating>> {
         let estimators = self.get_estimators(sources, |entry| &entry.fast)?;
         Ok(Arc::new(self.sanitized(Arc::new(
             RacingCompetitionEstimator::new(
                 vec![estimators],
                 fast_price_estimation_results_required,
+                native,
             ),
         ))))
     }
@@ -377,7 +380,12 @@ impl<'a> PriceEstimatorFactory<'a> {
             })
             .collect::<Result<Vec<Vec<_>>>>()?;
 
-        let competition_estimator = RacingCompetitionEstimator::new(estimators, results_required);
+        // Hack: we made the `RacingCompetitionEstimator` generic to reuse it for
+        // regular quotes and native quotes but only the regular quotes actually
+        // need the native price estimator component (otherwise we'd have a
+        // circular dependency). That's why we use the `NoopEstimator` here.
+        let competition_estimator =
+            RacingCompetitionEstimator::new(estimators, results_required, ());
         let native_estimator = Arc::new(CachingNativePriceEstimator::new(
             Box::new(competition_estimator),
             self.args.native_price_cache_max_age_secs,