Define protocol fee params and forward to driver

crates/autopilot/src/arguments.rs

@@ -208,6 +208,10 @@ pub struct Arguments {
     )]
     pub solve_deadline: Duration,
 
+    /// Describes how the protocol fee should be calculated.
+    #[clap(flatten)]
+    pub fee_policy: FeePolicy,
+
     /// Time interval in days between each cleanup operation of the
     /// `order_events` database table.
     #[clap(long, env, default_value = "1", value_parser = duration_from_days)]
@@ -284,6 +288,7 @@ impl std::fmt::Display for Arguments {
         writeln!(f, "score_cap: {}", self.score_cap)?;
         display_option(f, "shadow", &self.shadow)?;
         writeln!(f, "solve_deadline: {:?}", self.solve_deadline)?;
+        writeln!(f, "fee_policy: {}", self.fee_policy)?;
         writeln!(
             f,
             "order_events_cleanup_interval: {:?}",
@@ -298,6 +303,51 @@ impl std::fmt::Display for Arguments {
     }
 }
 
+#[derive(clap::Parser, Clone)]
+pub struct FeePolicy {
+    /// How much of the order's price improvement over max(limit price,
+    /// best_bid) should be taken as a protocol fee.
+    #[clap(
+        long,
+        env,
+        default_value = None,
+        value_parser = shared::arguments::parse_percentage_factor
+    )]
+    pub price_improvement_factor: Option<f64>,
+
+    /// How much of the order's volume should be taken as a protocol fee.
+    #[clap(
+        long,
+        env,
+        default_value = None,
+        value_parser = shared::arguments::parse_percentage_factor
+    )]
+    pub volume_factor: Option<f64>,
+
+    /// Should protocol fees be collected or skipped for limit orders with
+    /// in-market price at the time of order creation.
+    #[clap(long, env, action = clap::ArgAction::Set, default_value = "true")]
+    pub skip_in_market_orders: bool,
+
+    /// Should protocol fees be collected or skipped for TWAP limit orders.
+    #[clap(long, env, action = clap::ArgAction::Set, default_value = "true")]
+    pub skip_twap_orders: bool,
+}
+
+impl std::fmt::Display for FeePolicy {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "price_improvement_factor: {:?}, volume_factor: {:?}, skip_in_market_orders: {}, \
+             skip_twap_orders: {}",
+            self.price_improvement_factor,
+            self.volume_factor,
+            self.skip_in_market_orders,
+            self.skip_twap_orders
+        )
+    }
+}
+
 fn duration_from_days(s: &str) -> Result<Duration, ParseFloatError> {
     let days = s.parse::<f64>()?;
     Ok(Duration::from_secs_f64(days * 86_400.0))

crates/autopilot/src/driver_model.rs

@@ -115,6 +115,9 @@ pub mod solve {
         pub app_data: AppDataHash,
         #[serde(flatten)]
         pub signature: Signature,
+        /// The types of fees that will be collected by the protocol.
+        /// Multiple fees are applied in the order they are listed
+        pub fee_policies: Vec<FeePolicy>,
     }
 
     #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -150,6 +153,36 @@ pub mod solve {
         pub submission_address: H160,
     }
 
+    #[derive(Clone, Debug, Serialize, Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    pub enum FeePolicy {
+        /// If the order receives more than expected (positive deviation from
+        /// quoted amounts) pay the protocol a factor of the achieved
+        /// improvement. The fee is taken in `sell` token for `buy`
+        /// orders and in `buy` token for `sell` orders.
+        QuoteDeviation {
+            /// Factor of price improvement the protocol charges as a fee.
+            /// Price improvement is the difference between executed price and
+            /// limit price or quoted price (whichever is better)
+            ///
+            /// E.g. if a user received 2000USDC for 1ETH while having been
+            /// quoted 1990USDC, their price improvement is 10USDC.
+            /// A factor of 0.5 requires the solver to pay 5USDC to
+            /// the protocol for settling this order.
+            factor: f64,
+            /// Cap protocol fee with a percentage of the order's volume.
+            volume_cap_factor: Option<f64>,
+        },
+        /// How much of the order's volume should be taken as a protocol fee.
+        /// The fee is taken in `sell` token for `sell` orders and in `buy`
+        /// token for `buy` orders.
+        Volume {
+            /// Percentage of the order's volume should be taken as a protocol
+            /// fee.
+            factor: f64,
+        },
+    }
+
     #[derive(Clone, Debug, Default, Deserialize)]
     #[serde(rename_all = "camelCase", deny_unknown_fields)]
     pub struct Response {

crates/autopilot/src/run.rs

@@ -631,6 +631,7 @@ pub async fn run(args: Arguments) {
             max_settlement_transaction_wait: args.max_settlement_transaction_wait,
             solve_deadline: args.solve_deadline,
             in_flight_orders: Default::default(),
+            fee_policy: args.fee_policy,
         };
         run.run_forever().await;
         unreachable!("run loop exited");
@@ -692,6 +693,7 @@ async fn shadow_mode(args: Arguments) -> ! {
         trusted_tokens,
         args.score_cap,
         args.solve_deadline,
+        args.fee_policy,
     );
     shadow.run_forever().await;
 

crates/autopilot/src/run_loop.rs

@@ -1,5 +1,6 @@
 use {
     crate::{
+        arguments,
         database::{
             competition::{Competition, ExecutedFee, OrderExecution},
             Postgres,
@@ -8,7 +9,7 @@ use {
         driver_model::{
             reveal::{self, Request},
             settle,
-            solve::{self, Class},
+            solve::{self, Class, FeePolicy},
         },
         solvable_orders::SolvableOrdersCache,
     },
@@ -56,6 +57,7 @@ pub struct RunLoop {
     pub max_settlement_transaction_wait: Duration,
     pub solve_deadline: Duration,
     pub in_flight_orders: Arc<Mutex<InFlightOrders>>,
+    pub fee_policy: arguments::FeePolicy,
 }
 
 impl RunLoop {
@@ -306,6 +308,7 @@ impl RunLoop {
             &self.market_makable_token_list.all(),
             self.score_cap,
             self.solve_deadline,
+            self.fee_policy.clone(),
         );
         let request = &request;
 
@@ -488,6 +491,7 @@ pub fn solve_request(
     trusted_tokens: &HashSet<H160>,
     score_cap: U256,
     time_limit: Duration,
+    fee_policy: arguments::FeePolicy,
 ) -> solve::Request {
     solve::Request {
         id,
@@ -513,6 +517,28 @@ pub fn solve_request(
                             .collect()
                     };
                 let order_is_untouched = remaining_order.executed_amount.is_zero();
+                let fee_policy = match (
+                    fee_policy.price_improvement_factor,
+                    fee_policy.volume_factor,
+                ) {
+                    (Some(factor), volume_cap_factor) => Some(FeePolicy::QuoteDeviation {
+                        factor,
+                        volume_cap_factor,
+                    }),
+                    (None, Some(factor)) => Some(FeePolicy::Volume { factor }),
+                    (_, _) => None,
+                };
+
+                let fee_policies = match order.metadata.class {
+                    OrderClass::Market => vec![],
+                    OrderClass::Liquidity => vec![],
+                    // todo https://github.com/cowprotocol/services/issues/2092
+                    // skip protocol fee for limit orders with in-market price
+
+                    // todo https://github.com/cowprotocol/services/issues/2115
+                    // skip protocol fee for TWAP limit orders
+                    OrderClass::Limit(_) => fee_policy.map(|policy| vec![policy]).unwrap_or(vec![]),
+                };
                 solve::Order {
                     uid: order.metadata.uid,
                     sell_token: order.data.sell_token,
@@ -538,6 +564,7 @@ pub fn solve_request(
                     class,
                     app_data: order.data.app_data,
                     signature: order.signature.clone(),
+                    fee_policies,
                 }
             })
             .collect(),

crates/autopilot/src/shadow.rs

@@ -9,8 +9,12 @@
 
 use {
     crate::{
+        arguments::FeePolicy,
         driver_api::Driver,
-        driver_model::{reveal, solve},
+        driver_model::{
+            reveal,
+            solve::{self},
+        },
         protocol,
         run_loop,
     },
@@ -43,6 +47,7 @@ pub struct RunLoop {
     block: u64,
     score_cap: U256,
     solve_deadline: Duration,
+    fee_policy: FeePolicy,
 }
 
 impl RunLoop {
@@ -52,6 +57,7 @@ impl RunLoop {
         trusted_tokens: AutoUpdatingTokenList,
         score_cap: U256,
         solve_deadline: Duration,
+        fee_policy: FeePolicy,
     ) -> Self {
         Self {
             orderbook,
@@ -61,6 +67,7 @@ impl RunLoop {
             block: 0,
             score_cap,
             solve_deadline,
+            fee_policy,
         }
     }
 
@@ -193,6 +200,7 @@ impl RunLoop {
             &self.trusted_tokens.all(),
             self.score_cap,
             self.solve_deadline,
+            self.fee_policy.clone(),
         );
         let request = &request;
 

crates/driver/src/domain/competition/order/fees.rs

@@ -0,0 +1,28 @@
+#[derive(Clone, Debug)]
+pub enum FeePolicy {
+    /// If the order receives more than expected (positive deviation from quoted
+    /// amounts) pay the protocol a factor of the achieved improvement.
+    /// The fee is taken in `sell` token for `buy` orders and in `buy`
+    /// token for `sell` orders.
+    QuoteDeviation {
+        /// Factor of price improvement the protocol charges as a fee.
+        /// Price improvement is the difference between executed price and
+        /// limit price or quoted price (whichever is better)
+        ///
+        /// E.g. if a user received 2000USDC for 1ETH while having been quoted
+        /// 1990USDC, their price improvement is 10USDC. A factor of 0.5
+        /// requires the solver to pay 5USDC to the protocol for
+        /// settling this order.
+        factor: f64,
+        /// Cap protocol fee with a percentage of the order's volume.
+        volume_cap_factor: f64,
+    },
+    /// How much of the order's volume should be taken as a protocol fee.
+    /// The fee is taken in `sell` token for `sell` orders and in `buy`
+    /// token for `buy` orders.
+    Volume {
+        /// Percentage of the order's volume should be taken as a protocol
+        /// fee.
+        factor: f64,
+    },
+}

crates/driver/src/domain/competition/order/mod.rs

@@ -1,4 +1,3 @@
-pub use signature::Signature;
 use {
     super::auction,
     crate::{
@@ -9,7 +8,9 @@ use {
     bigdecimal::Zero,
     num::CheckedDiv,
 };
+pub use {fees::FeePolicy, signature::Signature};
 
+pub mod fees;
 pub mod signature;
 
 /// An order in the auction.
@@ -39,6 +40,10 @@ pub struct Order {
     pub sell_token_balance: SellTokenBalance,
     pub buy_token_balance: BuyTokenBalance,
     pub signature: Signature,
+    /// The types of fees the protocol collects from the winning solver.
+    /// Unless otherwise configured, the driver modifies solutions to take
+    /// sufficient fee in the form of positive slippage.
+    pub fee_policies: Vec<FeePolicy>,
 }
 
 /// An amount denominated in the sell token of an [`Order`].
@@ -453,6 +458,7 @@ mod tests {
                 data: Default::default(),
                 signer: Default::default(),
             },
+            fee_policies: Default::default(),
         };
 
         assert_eq!(

crates/driver/src/domain/quote.rs

@@ -135,6 +135,7 @@ impl Order {
                     data: Default::default(),
                     signer: Default::default(),
                 },
+                fee_policies: Default::default(),
             }],
             [
                 auction::Token {

crates/driver/src/infra/api/routes/solve/dto/auction.rs

@@ -115,6 +115,22 @@ impl Auction {
                         data: order.signature.into(),
                         signer: order.owner.into(),
                     },
+                    fee_policies: order
+                        .fee_policies
+                        .into_iter()
+                        .map(|policy| match policy {
+                            FeePolicy::QuoteDeviation {
+                                factor,
+                                volume_cap_factor,
+                            } => competition::order::FeePolicy::QuoteDeviation {
+                                factor,
+                                volume_cap_factor,
+                            },
+                            FeePolicy::Volume { factor } => {
+                                competition::order::FeePolicy::Volume { factor }
+                            }
+                        })
+                        .collect(),
                 })
                 .collect(),
             self.tokens.into_iter().map(|token| {
@@ -234,6 +250,7 @@ struct Order {
     signing_scheme: SigningScheme,
     #[serde_as(as = "serialize::Hex")]
     signature: Vec<u8>,
+    fee_policies: Vec<FeePolicy>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -287,3 +304,10 @@ enum Class {
     Limit,
     Liquidity,
 }
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+enum FeePolicy {
+    QuoteDeviation { factor: f64, volume_cap_factor: f64 },
+    Volume { factor: f64 },
+}

crates/driver/src/tests/setup/driver.rs

@@ -99,7 +99,18 @@ pub fn solve_req(test: &Test) -> serde_json::Value {
             },
             "appData": "0x0000000000000000000000000000000000000000000000000000000000000000",
             "signingScheme": "eip712",
-            "signature": format!("0x{}", hex::encode(quote.order_signature(&test.blockchain)))
+            "signature": format!("0x{}", hex::encode(quote.order_signature(&test.blockchain))),
+            "feePolicies": [{
+                "quoteDeviation": {
+                    "factor": 0.5,
+                    "volume_cap_factor": 0.06,
+                }
+            },
+            {
+                "volume": {
+                    "factor": 0.1,
+                }
+            }],
         }));
     }
     for fulfillment in test.fulfillments.iter() {