[BLOCKED] Save executed fee in surplus token

crates/autopilot/src/domain/eth/mod.rs

@@ -179,6 +179,7 @@ impl From<EffectiveGasPrice> for U256 {
         value.0.into()
     }
 }
+
 impl std::ops::Sub<Self> for TokenAmount {
     type Output = TokenAmount;
 

crates/autopilot/src/domain/settlement/mod.rs

@@ -100,12 +100,9 @@ impl Settlement {
                         "possible incomplete fee breakdown calculation",
                     );
                     trade::FeeBreakdown {
-                        total: eth::Asset {
-                            // TODO surplus token
-                            token: trade.sell_token(),
-                            amount: num::zero(),
-                        },
+                        executed: num::zero(),
                         protocol: vec![],
+                        token: trade.surplus_token(),
                     }
                 });
                 (*trade.uid(), fee_breakdown)
@@ -353,6 +350,15 @@ mod tests {
             trade.fee_in_ether(&auction.prices).unwrap().0,
             eth::U256::from(6752697350740628u128)
         );
+        // fee read from "executedFee" https://api.cow.fi/mainnet/api/v1/orders/0x10dab31217bb6cc2ace0fe601c15d342f7626a1ee5ef0495449800e73156998740a50cf069e992aa4536211b23f286ef88752187ffffffff
+        // and then using UCP prices from https://api.cow.fi/mainnet/api/v1/solver_competition/by_tx_hash/0xc48dc0d43ffb43891d8c3ad7bcf05f11465518a2610869b20b0b4ccb61497634
+        // fee can be converted to surplus token:
+        // 6890975030480504 / 10115523891911314 * 18446744073709551616 =
+        // 12566432956304187498
+        assert_eq!(
+            trade.fee_breakdown(&auction).unwrap().executed.0,
+            eth::U256::from(12566432956304187498u128)
+        );
     }
 
     // https://etherscan.io/tx/0x688508eb59bd20dc8c0d7c0c0b01200865822c889f0fcef10113e28202783243
@@ -828,7 +834,7 @@ mod tests {
         assert_eq!(jit_trade.fee_in_ether(&auction.prices).unwrap().0, 0.into());
         assert_eq!(jit_trade.score(&auction).unwrap().0, 0.into());
         assert_eq!(
-            jit_trade.fee_breakdown(&auction).unwrap().total.amount.0,
+            jit_trade.fee_breakdown(&auction).unwrap().executed.0,
             0.into()
         );
         assert!(jit_trade

crates/autopilot/src/domain/settlement/trade/math.rs

@@ -1,6 +1,5 @@
 pub use error::Error;
 use {
-    super::ExecutedProtocolFee,
     crate::{
         domain::{
             self,
@@ -47,7 +46,7 @@ impl Trade {
         &self,
         prices: &ClearingPrices,
         price_limits: PriceLimits,
-    ) -> Result<eth::Asset, error::Math> {
+    ) -> Result<eth::TokenAmount, error::Math> {
         match self.side {
             order::Side::Buy => {
                 // scale limit sell to support partially fillable orders
@@ -91,78 +90,57 @@ impl Trade {
                 bought.checked_sub(limit_buy).ok_or(error::Math::Negative)
             }
         }
-        .map(|surplus| eth::Asset {
-            token: self.surplus_token(),
-            amount: surplus.into(),
-        })
+        .map(eth::TokenAmount)
     }
 
     /// Surplus based on custom clearing prices returns the surplus after all
     /// fees have been applied.
     pub fn surplus_in_ether(&self, prices: &auction::Prices) -> Result<eth::Ether, Error> {
         let surplus = self.surplus_over_limit_price()?;
         let price = prices
-            .get(&surplus.token)
-            .ok_or(Error::MissingPrice(surplus.token))?;
+            .get(&self.surplus_token())
+            .ok_or(Error::MissingPrice(self.surplus_token()))?;
 
-        Ok(price.in_eth(surplus.amount))
+        Ok(price.in_eth(surplus))
     }
 
-    /// Total fee (protocol fee + network fee). Equal to a surplus difference
+    /// Total fee (protocol fee + gas fee). Equal to a surplus difference
     /// before and after applying the fees.
     pub fn fee_in_ether(&self, prices: &auction::Prices) -> Result<eth::Ether, Error> {
         let fee = self.fee()?;
         let price = prices
-            .get(&fee.token)
-            .ok_or(Error::MissingPrice(fee.token))?;
-        Ok(price.in_eth(fee.amount))
+            .get(&self.surplus_token())
+            .ok_or(Error::MissingPrice(self.surplus_token()))?;
+        Ok(price.in_eth(fee))
     }
 
-    /// Converts given surplus fee into sell token fee.
-    fn fee_into_sell_token(&self, fee: eth::TokenAmount) -> Result<eth::SellTokenAmount, Error> {
-        let fee_in_sell_token = match self.side {
-            order::Side::Buy => fee,
-            order::Side::Sell => fee
-                .checked_mul(&self.prices.uniform.buy.into())
-                .ok_or(error::Math::Overflow)?
-                .checked_div(&self.prices.uniform.sell.into())
-                .ok_or(error::Math::DivisionByZero)?,
-        }
-        .into();
-        Ok(fee_in_sell_token)
-    }
-
-    /// Total fee (protocol fee + network fee). Equal to a surplus difference
-    /// before and after applying the fees.
-    pub fn fee_in_sell_token(&self) -> Result<eth::Asset, Error> {
-        let fee = self.fee()?;
-        self.fee_into_sell_token(fee.amount)
-            .map(|amount| eth::Asset {
-                token: self.sell.token,
-                amount: amount.into(),
-            })
+    /// Complete breakdown of all fees taken for the trade.
+    ///
+    /// Denominated in SURPLUS token
+    pub fn fee_breakdown(&self, auction: &settlement::Auction) -> Result<FeeBreakdown, Error> {
+        Ok(FeeBreakdown {
+            executed: self.fee()?,
+            protocol: self.protocol_fees(auction)?,
+            token: self.surplus_token(),
+        })
     }
 
-    /// Total fee (protocol fee + network fee). Equal to a surplus difference
+    /// Total fee (protocol fee + gas fee). Equal to a surplus difference
     /// before and after applying the fees.
     ///
     /// Denominated in SURPLUS token
-    fn fee(&self) -> Result<eth::Asset, Error> {
+    fn fee(&self) -> Result<eth::TokenAmount, Error> {
         let fee = self
             .surplus_over_limit_price_before_fee()?
-            .amount
-            .checked_sub(&self.surplus_over_limit_price()?.amount)
+            .checked_sub(&self.surplus_over_limit_price()?)
             .ok_or(error::Math::Negative)?;
-        Ok(eth::Asset {
-            token: self.surplus_token(),
-            amount: fee,
-        })
+        Ok(fee)
     }
 
     /// Protocol fees are defined by fee policies attached to the order.
     ///
     /// Denominated in SURPLUS token
-    pub fn protocol_fees(
+    fn protocol_fees(
         &self,
         auction: &settlement::Auction,
     ) -> Result<Vec<ExecutedProtocolFee>, Error> {
@@ -182,7 +160,7 @@ impl Trade {
                 policy: *policy,
                 fee,
             });
-            total += fee.amount;
+            total += fee;
             if !i.is_zero() {
                 current_trade.prices.custom = self.calculate_custom_prices(total)?;
             }
@@ -259,16 +237,16 @@ impl Trade {
     /// Protocol fee is defined by a fee policy attached to the order.
     ///
     /// Denominated in SURPLUS token
-    fn protocol_fee(&self, fee_policy: &fee::Policy) -> Result<eth::Asset, Error> {
+    fn protocol_fee(&self, fee_policy: &fee::Policy) -> Result<eth::TokenAmount, Error> {
         let amount = match fee_policy {
             fee::Policy::Surplus {
                 factor,
                 max_volume_factor,
             } => {
                 let surplus = self.surplus_over_limit_price()?;
                 std::cmp::min(
-                    self.surplus_fee(surplus, (*factor).into())?.amount,
-                    self.volume_fee((*max_volume_factor).into())?.amount,
+                    self.surplus_fee(surplus, (*factor).into())?,
+                    self.volume_fee((*max_volume_factor).into())?,
                 )
             }
             fee::Policy::PriceImprovement {
@@ -278,35 +256,28 @@ impl Trade {
             } => {
                 let price_improvement = self.price_improvement(quote)?;
                 std::cmp::min(
-                    self.surplus_fee(price_improvement, (*factor).into())?
-                        .amount,
-                    self.volume_fee((*max_volume_factor).into())?.amount,
+                    self.surplus_fee(price_improvement, (*factor).into())?,
+                    self.volume_fee((*max_volume_factor).into())?,
                 )
             }
-            fee::Policy::Volume { factor } => self.volume_fee((*factor).into())?.amount,
+            fee::Policy::Volume { factor } => self.volume_fee((*factor).into())?,
         };
-        Ok(eth::Asset {
-            token: self.surplus_token(),
-            amount,
-        })
+        Ok(amount)
     }
 
-    fn price_improvement(&self, quote: &domain::fee::Quote) -> Result<eth::Asset, Error> {
+    fn price_improvement(&self, quote: &domain::fee::Quote) -> Result<eth::TokenAmount, Error> {
         let surplus = self.surplus_over_quote(quote);
         // negative surplus is not error in this case, as solutions often have no
         // improvement over quote which results in negative surplus
         if let Err(error::Math::Negative) = surplus {
-            return Ok(eth::Asset {
-                token: self.surplus_token(),
-                amount: Default::default(),
-            });
+            return Ok(num::zero());
         }
         Ok(surplus?)
     }
 
     /// Uses custom prices to calculate the surplus after the protocol fee and
-    /// network fee are applied.
-    fn surplus_over_limit_price(&self) -> Result<eth::Asset, error::Math> {
+    /// gas fee are applied.
+    fn surplus_over_limit_price(&self) -> Result<eth::TokenAmount, error::Math> {
         let limit_price = PriceLimits {
             sell: self.sell.amount,
             buy: self.buy.amount,
@@ -315,16 +286,19 @@ impl Trade {
     }
 
     /// Uses uniform prices to calculate the surplus as if the protocol fee and
-    /// network fee are not applied.
-    fn surplus_over_limit_price_before_fee(&self) -> Result<eth::Asset, error::Math> {
+    /// gas fee are not applied.
+    fn surplus_over_limit_price_before_fee(&self) -> Result<eth::TokenAmount, error::Math> {
         let limit_price = PriceLimits {
             sell: self.sell.amount,
             buy: self.buy.amount,
         };
         self.surplus_over(&self.prices.uniform, limit_price)
     }
 
-    fn surplus_over_quote(&self, quote: &domain::fee::Quote) -> Result<eth::Asset, error::Math> {
+    fn surplus_over_quote(
+        &self,
+        quote: &domain::fee::Quote,
+    ) -> Result<eth::TokenAmount, error::Math> {
         let quote = adjust_quote_to_order_limits(
             Order {
                 sell: self.sell.amount,
@@ -341,7 +315,11 @@ impl Trade {
     }
 
     /// Protocol fee as a cut of surplus, denominated in SURPLUS token
-    fn surplus_fee(&self, surplus: eth::Asset, factor: f64) -> Result<eth::Asset, Error> {
+    fn surplus_fee(
+        &self,
+        surplus: eth::TokenAmount,
+        factor: f64,
+    ) -> Result<eth::TokenAmount, Error> {
         // Surplus fee is specified as a `factor` from raw surplus (before fee). Since
         // this module works with trades that already have the protocol fee applied, we
         // need to calculate the protocol fee as an observation of the eventually traded
@@ -360,18 +338,13 @@ impl Trade {
         // Finally:
         //     fee = surplus_after_fee * factor / (1 - factor)
         let fee = surplus
-            .amount
             .apply_factor(factor / (1.0 - factor))
             .ok_or(error::Math::Overflow)?;
-
-        Ok(eth::Asset {
-            token: surplus.token,
-            amount: fee,
-        })
+        Ok(fee)
     }
 
     /// Protocol fee as a cut of the trade volume, denominated in SURPLUS token
-    fn volume_fee(&self, factor: f64) -> Result<eth::Asset, Error> {
+    fn volume_fee(&self, factor: f64) -> Result<eth::TokenAmount, Error> {
         // Volume fee is specified as a `factor` from raw volume (before fee). Since
         // this module works with trades that already have the protocol fee applied, we
         // need to calculate the protocol fee as an observation of a the eventually
@@ -409,14 +382,10 @@ impl Trade {
             order::Side::Buy => factor / (1.0 + factor),
         };
 
-        Ok(eth::Asset {
-            token: self.surplus_token(),
-            amount: {
-                executed_in_surplus_token
-                    .apply_factor(factor)
-                    .ok_or(error::Math::Overflow)?
-            },
-        })
+        let fee = executed_in_surplus_token
+            .apply_factor(factor)
+            .ok_or(error::Math::Overflow)?;
+        Ok(fee)
     }
 
     /// Protocol fee is defined by fee policies attached to the order.
@@ -426,9 +395,9 @@ impl Trade {
             .map(|ExecutedProtocolFee { fee, policy: _ }| {
                 let price = auction
                     .prices
-                    .get(&fee.token)
-                    .ok_or(Error::MissingPrice(fee.token))?;
-                Ok(price.in_eth(fee.amount))
+                    .get(&self.surplus_token())
+                    .ok_or(Error::MissingPrice(self.surplus_token()))?;
+                Ok(price.in_eth(fee))
             })
             .sum()
     }
@@ -441,6 +410,27 @@ impl Trade {
     }
 }
 
+/// Fee per trade in a solution. These fees are taken for the execution of the
+/// trade.
+#[derive(Debug, Clone)]
+pub struct FeeBreakdown {
+    /// Fee reported by solvers, representing difference between UCP and custom
+    /// prices.
+    pub executed: eth::TokenAmount,
+    /// Breakdown of protocol fees.
+    pub protocol: Vec<ExecutedProtocolFee>,
+    /// Surplus token in which all the fees were taken.
+    pub token: eth::TokenAddress,
+}
+
+#[derive(Debug, Clone)]
+pub struct ExecutedProtocolFee {
+    /// Policy that was used to calculate the fee.
+    pub policy: fee::Policy,
+    /// Fee that was taken for the trade, in surplus token.
+    pub fee: eth::TokenAmount,
+}
+
 #[derive(Clone, Debug)]
 pub struct PriceLimits {
     pub sell: eth::TokenAmount,