Move out protocol fee into separate file

crates/autopilot/src/protocol/fee.rs

@@ -0,0 +1,50 @@
+//! Protocol fee implementation.
+//!
+//! The protocol fee is a fee that is defined by the protocol and for each order
+//! in the auction we define the way to calculate the protocol fee based on the
+//! configuration parameters.
+
+use {
+    crate::{
+        arguments,
+        driver_model::solve::{fee_policy_to_dto, FeePolicy},
+    },
+    model::{
+        auction::Auction,
+        order::{OrderClass, OrderUid},
+    },
+    std::collections::HashMap,
+};
+
+pub struct Policies {
+    policies: HashMap<OrderUid, Vec<FeePolicy>>,
+}
+
+impl Policies {
+    pub fn new(auction: &Auction, config: arguments::FeePolicy) -> Self {
+        Self {
+            policies: auction
+                .orders
+                .iter()
+                .filter_map(|order| {
+                    match order.metadata.class {
+                        OrderClass::Market => None,
+                        OrderClass::Liquidity => None,
+                        // 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(_) => {
+                            Some((order.metadata.uid, vec![fee_policy_to_dto(&config)]))
+                        }
+                    }
+                })
+                .collect(),
+        }
+    }
+
+    pub fn get(&self, order: &OrderUid) -> Option<Vec<FeePolicy>> {
+        self.policies.get(order).cloned()
+    }
+}

crates/autopilot/src/protocol/mod.rs

@@ -1,6 +1,7 @@
 //! A top-level containing implementations of clients to other CoW Protocol
 //! components.
 
+pub mod fee;
 pub mod orderbook;
 
 pub use self::orderbook::Orderbook;

crates/autopilot/src/run_loop.rs

@@ -9,8 +9,9 @@ use {
         driver_model::{
             reveal::{self, Request},
             settle,
-            solve::{self, fee_policy_to_dto, Class, TradedAmounts},
+            solve::{self, Class, TradedAmounts},
         },
+        protocol::fee,
         solvable_orders::SolvableOrdersCache,
     },
     anyhow::Result,
@@ -309,13 +310,14 @@ impl RunLoop {
 
     /// Runs the solver competition, making all configured drivers participate.
     async fn competition(&self, id: AuctionId, auction: &Auction) -> Vec<Participant<'_>> {
+        let fee_policies = fee::Policies::new(auction, self.fee_policy.clone());
         let request = solve_request(
             id,
             auction,
             &self.market_makable_token_list.all(),
             self.score_cap,
             self.solve_deadline,
-            self.fee_policy.clone(),
+            fee_policies,
         );
         let request = &request;
 
@@ -499,7 +501,7 @@ pub fn solve_request(
     trusted_tokens: &HashSet<H160>,
     score_cap: U256,
     time_limit: Duration,
-    fee_policy: arguments::FeePolicy,
+    fee_policies: fee::Policies,
 ) -> solve::Request {
     solve::Request {
         id,
@@ -525,17 +527,6 @@ pub fn solve_request(
                             .collect()
                     };
                 let order_is_untouched = remaining_order.executed_amount.is_zero();
-
-                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(_) => vec![fee_policy_to_dto(&fee_policy)],
-                };
                 solve::Order {
                     uid: order.metadata.uid,
                     sell_token: order.data.sell_token,
@@ -561,7 +552,7 @@ pub fn solve_request(
                     class,
                     app_data: order.data.app_data,
                     signature: order.signature.clone(),
-                    fee_policies,
+                    fee_policies: fee_policies.get(&order.metadata.uid).unwrap_or_default(),
                 }
             })
             .collect(),

crates/autopilot/src/shadow.rs

@@ -15,7 +15,7 @@ use {
             reveal,
             solve::{self},
         },
-        protocol,
+        protocol::{self, fee},
         run_loop,
     },
     model::{
@@ -194,13 +194,14 @@ impl RunLoop {
 
     /// Runs the solver competition, making all configured drivers participate.
     async fn competition(&self, id: AuctionId, auction: &Auction) -> Vec<Participant<'_>> {
+        let fee_policies = fee::Policies::new(auction, self.fee_policy.clone());
         let request = run_loop::solve_request(
             id,
             auction,
             &self.trusted_tokens.all(),
             self.score_cap,
             self.solve_deadline,
-            self.fee_policy.clone(),
+            fee_policies,
         );
         let request = &request;